Merge branch 'develop' into feat/signature-count-endpoint

Author: saralab

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

@@ -538,6 +538,36 @@ impl<'a> TestPeer<'a> {
         miner_setup: F,
         after_block: G,
     ) -> NakamotoBlock
+    where
+        F: FnMut(&mut NakamotoBlockBuilder),
+        G: FnMut(&mut NakamotoBlock) -> bool,
+    {
+        let nakamoto_tip = {
+            let chainstate = &mut self.stacks_node.as_mut().unwrap().chainstate;
+            let sort_db = self.sortdb.as_mut().unwrap();
+            NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+                .unwrap()
+                .unwrap()
+        };
+        self.mine_single_block_tenure_at_tip(
+            &nakamoto_tip.index_block_hash(),
+            sender_key,
+            tenure_change_tx,
+            coinbase_tx,
+            miner_setup,
+            after_block,
+        )
+    }
+
+    pub fn mine_single_block_tenure_at_tip<F, G>(
+        &mut self,
+        nakamoto_tip: &StacksBlockId,
+        sender_key: &StacksPrivateKey,
+        tenure_change_tx: &StacksTransaction,
+        coinbase_tx: &StacksTransaction,
+        miner_setup: F,
+        after_block: G,
+    ) -> NakamotoBlock
     where
         F: FnMut(&mut NakamotoBlockBuilder),
         G: FnMut(&mut NakamotoBlock) -> bool,
@@ -547,6 +577,8 @@ impl<'a> TestPeer<'a> {
         let recipient_addr =
             StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
 
+        let sender_acct = self.get_account(nakamoto_tip, &sender_addr.to_account_principal());
+
         // do a stx transfer in each block to a given recipient
         let mut blocks_and_sizes = self.make_nakamoto_tenure_and(
             tenure_change_tx.clone(),
@@ -555,12 +587,11 @@ impl<'a> TestPeer<'a> {
             miner_setup,
             |_miner, chainstate, sortdb, blocks_so_far| {
                 if blocks_so_far.len() < 1 {
-                    let account = get_account(chainstate, sortdb, &sender_addr);
                     let stx_transfer = make_token_transfer(
                         chainstate,
                         sortdb,
                         &sender_key,
-                        account.nonce,
+                        sender_acct.nonce,
                         100,
                         1,
                         &recipient_addr,
@@ -607,12 +638,33 @@ impl<'a> TestPeer<'a> {
         tenure_change.tenure_consensus_hash = consensus_hash.clone();
         tenure_change.burn_view_consensus_hash = consensus_hash.clone();
 
+        let nakamoto_tip =
+            if let Some(nakamoto_parent_tenure) = self.nakamoto_parent_tenure_opt.as_ref() {
+                nakamoto_parent_tenure.last().as_ref().unwrap().block_id()
+            } else {
+                let tip = {
+                    let chainstate = &mut self.stacks_node.as_mut().unwrap().chainstate;
+                    let sort_db = self.sortdb.as_mut().unwrap();
+                    NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+                        .unwrap()
+                        .unwrap()
+                };
+                tip.index_block_hash()
+            };
+
+        let miner_addr = self.miner.origin_address().unwrap();
+        let miner_acct = self.get_account(&nakamoto_tip, &miner_addr.to_account_principal());
+
         let tenure_change_tx = self
             .miner
-            .make_nakamoto_tenure_change(tenure_change.clone());
-        let coinbase_tx = self.miner.make_nakamoto_coinbase(None, vrf_proof);
+            .make_nakamoto_tenure_change_with_nonce(tenure_change.clone(), miner_acct.nonce);
+
+        let coinbase_tx =
+            self.miner
+                .make_nakamoto_coinbase_with_nonce(None, vrf_proof, miner_acct.nonce + 1);
 
-        let block = self.mine_single_block_tenure(
+        let block = self.mine_single_block_tenure_at_tip(
+            &nakamoto_tip,
             sender_key,
             &tenure_change_tx,
             &coinbase_tx,

stackslib/src/chainstate/nakamoto/mod.rs

@@ -110,8 +110,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, sqlite_open, tx_begin_immediate, u64_to_sql,
-    DBConn, Error as DBError, FromRow,
+    query_int, query_row, query_row_columns, query_row_panic, query_rows, sqlite_open,
+    tx_begin_immediate, u64_to_sql, DBConn, Error as DBError, FromRow,
 };
 use crate::{chainstate, monitoring};
 
@@ -2500,6 +2500,26 @@ impl NakamotoChainState {
         Ok(None)
     }
 
+    /// Load the parent block ID of a Nakamoto block
+    pub fn get_nakamoto_parent_block_id(
+        chainstate_conn: &Connection,
+        index_block_hash: &StacksBlockId,
+    ) -> Result<Option<StacksBlockId>, ChainstateError> {
+        let sql = "SELECT parent_block_id FROM nakamoto_block_headers WHERE index_block_hash = ?1";
+        let mut result = query_row_columns(
+            chainstate_conn,
+            sql,
+            &[&index_block_hash],
+            "parent_block_id",
+        )?;
+        if result.len() > 1 {
+            // even though `(consensus_hash,block_hash)` is the primary key, these are hashed to
+            // produce `index_block_hash`.  So, `index_block_hash` is also unique w.h.p.
+            unreachable!("FATAL: multiple instances of index_block_hash");
+        }
+        Ok(result.pop())
+    }
+
     /// Load a Nakamoto header
     pub fn get_block_header_nakamoto(
         chainstate_conn: &Connection,