feat: Refactor replay_block() and use it to validate mock mined blocks

Author: jbencin

stackslib/src/chainstate/stacks/block.rs

@@ -651,6 +651,14 @@ impl StacksBlock {
     pub fn has_microblock_parent(&self) -> bool {
         self.header.has_microblock_parent()
     }
+
+    /// Returns size in bytes of `StacksMessageCodec` representation
+    /// Note that this will serialize the block, so don't call if there is a better way to get block size
+    pub fn block_size(&self) -> Result<usize, codec_error> {
+        let mut buf = vec![];
+        self.consensus_serialize(&mut buf)?;
+        Ok(buf.len())
+    }
 }
 
 impl StacksMessageCodec for StacksMicroblockHeader {

stackslib/src/chainstate/stacks/db/blocks.rs

@@ -3716,30 +3716,44 @@ impl StacksChainState {
         blocks_conn: &DBConn,
         staging_block: &StagingBlock,
     ) -> Result<Option<Vec<StacksMicroblock>>, Error> {
-        if staging_block.parent_microblock_hash == EMPTY_MICROBLOCK_PARENT_HASH
-            && staging_block.parent_microblock_seq == 0
-        {
+        Self::inner_find_parent_microblock_stream(
+            blocks_conn,
+            &staging_block.anchored_block_hash,
+            &staging_block.parent_anchored_block_hash,
+            &staging_block.parent_consensus_hash,
+            &staging_block.parent_microblock_hash,
+            staging_block.parent_microblock_seq,
+        )
+    }
+
+    /// Allow `find_parent_microblock_stream()` to be called without `StagingBlock`
+    pub fn inner_find_parent_microblock_stream(
+        blocks_conn: &DBConn,
+        anchored_block_hash: &BlockHeaderHash,
+        parent_anchored_block_hash: &BlockHeaderHash,
+        parent_consensus_hash: &ConsensusHash,
+        parent_microblock_hash: &BlockHeaderHash,
+        parent_microblock_seq: u16,
+    ) -> Result<Option<Vec<StacksMicroblock>>, Error> {
+        if *parent_microblock_hash == EMPTY_MICROBLOCK_PARENT_HASH && parent_microblock_seq == 0 {
             // no parent microblocks, ever
             return Ok(Some(vec![]));
         }
 
         // find the microblock stream fork that this block confirms
         match StacksChainState::load_microblock_stream_fork(
             blocks_conn,
-            &staging_block.parent_consensus_hash,
-            &staging_block.parent_anchored_block_hash,
-            &staging_block.parent_microblock_hash,
+            parent_consensus_hash,
+            parent_anchored_block_hash,
+            parent_microblock_hash,
         )? {
             Some(microblocks) => {
                 return Ok(Some(microblocks));
             }
             None => {
                 // parent microblocks haven't arrived yet, or there are none
                 debug!(
-                    "No parent microblock stream for {}: expected a stream with tail {},{}",
-                    staging_block.anchored_block_hash,
-                    staging_block.parent_microblock_hash,
-                    staging_block.parent_microblock_seq
+                    "No parent microblock stream for {anchored_block_hash}: expected a stream with tail {parent_microblock_hash},{parent_microblock_seq}",
                 );
                 return Ok(None);
             }

stackslib/src/chainstate/stacks/miner.rs

@@ -73,6 +73,8 @@ use crate::net::Error as net_error;
 pub struct AssembledAnchorBlock {
     /// Consensus hash of the parent Stacks block
     pub parent_consensus_hash: ConsensusHash,
+    /// Consensus hash this Stacks block
+    pub consensus_hash: ConsensusHash,
     /// Burnchain tip's block hash when we finished mining
     pub my_burn_hash: BurnchainHeaderHash,
     /// Burnchain tip's block height when we finished mining