feat: API for choosing which Nakamoto tenure to mine on

Author: jcnelson

stackslib/src/net/mod.rs

@@ -2275,6 +2275,10 @@ pub mod test {
         >,
         /// list of malleablized blocks produced when mining.
         pub malleablized_blocks: Vec<NakamotoBlock>,
+        pub mine_malleablized_blocks: bool,
+        /// tenure-start block of tenure to mine on.
+        /// gets consumed on the call to begin_nakamoto_tenure
+        pub nakamoto_parent_tenure_opt: Option<Vec<NakamotoBlock>>,
     }
 
     impl<'a> TestPeer<'a> {
@@ -2689,6 +2693,8 @@ pub mod test {
                 coord: coord,
                 indexer: Some(indexer),
                 malleablized_blocks: vec![],
+                mine_malleablized_blocks: true,
+                nakamoto_parent_tenure_opt: None,
             }
         }
 
@@ -3509,6 +3515,10 @@ pub mod test {
             self.sortdb.as_mut().unwrap()
         }
 
+        pub fn sortdb_ref(&mut self) -> &SortitionDB {
+            self.sortdb.as_ref().unwrap()
+        }
+
         pub fn with_db_state<F, R>(&mut self, f: F) -> Result<R, net_error>
         where
             F: FnOnce(
@@ -4198,6 +4208,43 @@ pub mod test {
                 }
             }
         }
+
+        /// Set the nakamoto tenure to mine on
+        pub fn mine_nakamoto_on(&mut self, parent_tenure: Vec<NakamotoBlock>) {
+            self.nakamoto_parent_tenure_opt = Some(parent_tenure);
+        }
+
+        /// Clear the tenure to mine on. This causes the miner to build on the canonical tip
+        pub fn mine_nakamoto_on_canonical_tip(&mut self) {
+            self.nakamoto_parent_tenure_opt = None;
+        }
+
+        /// Get an account off of a tip
+        pub fn get_account(
+            &mut self,
+            tip: &StacksBlockId,
+            account: &PrincipalData,
+        ) -> StacksAccount {
+            let sortdb = self.sortdb.take().expect("FATAL: sortdb not restored");
+            let mut node = self
+                .stacks_node
+                .take()
+                .expect("FATAL: chainstate not restored");
+
+            let acct = node
+                .chainstate
+                .maybe_read_only_clarity_tx(
+                    &sortdb.index_handle_at_block(&node.chainstate, tip).unwrap(),
+                    tip,
+                    |clarity_tx| StacksChainState::get_account(clarity_tx, account),
+                )
+                .unwrap()
+                .unwrap();
+
+            self.sortdb = Some(sortdb);
+            self.stacks_node = Some(node);
+            acct
+        }
     }
 
     pub fn to_addr(sk: &StacksPrivateKey) -> StacksAddress {