feat: add dropped blocks to tenure forking info API

Author: hstove

stackslib/src/chainstate/nakamoto/staging_blocks.rs

@@ -428,6 +428,30 @@ impl<'a> NakamotoStagingBlocksConnRef<'a> {
             .collect())
     }
 
+    /// Get all nakamoto blocks in a tenure
+    pub fn get_nakamoto_blocks_in_tenure(
+        &self,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<Vec<NakamotoBlock>, ChainstateError> {
+        let qry =
+            "SELECT data FROM nakamoto_staging_blocks WHERE consensus_hash = ?1 AND processed = 1";
+        let args = params![consensus_hash];
+        let block_data: Vec<Vec<u8>> = query_rows(self, qry, args)?;
+        Ok(block_data
+            .into_iter()
+            .filter_map(|block_vec| {
+                NakamotoBlock::consensus_deserialize(&mut &block_vec[..])
+                    .map_err(|e| {
+                        error!("Failed to deserialize block from DB, likely database corruption";
+                               "consensus_hash" => %consensus_hash,
+                               "error" => ?e);
+                        e
+                    })
+                    .ok()
+            })
+            .collect())
+    }
+
     /// 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

stackslib/src/net/api/get_tenures_fork_info.rs

@@ -34,7 +34,7 @@ use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState, NakamotoSta
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::Error as ChainError;
 use crate::net::api::getblock_v3::NakamotoBlockStream;
-use crate::net::api::{prefix_hex, prefix_opt_hex};
+use crate::net::api::{prefix_hex, prefix_opt_hex, prefix_opt_hex_codec};
 use crate::net::http::{
     parse_bytes, parse_json, Error, HttpBadRequest, HttpChunkGenerator, HttpContentType,
     HttpNotFound, HttpRequest, HttpRequestContents, HttpRequestPreamble, HttpResponse,
@@ -80,6 +80,9 @@ pub struct TenureForkingInfo {
     /// tenure's first block.
     #[serde(with = "prefix_opt_hex")]
     pub first_block_mined: Option<StacksBlockId>,
+    /// Nakamoto blocks in the tenure
+    #[serde(with = "prefix_opt_hex_codec")]
+    pub nakamoto_blocks: Option<Vec<NakamotoBlock>>,
 }
 
 #[derive(Clone, Default)]
@@ -154,8 +157,8 @@ impl TenureForkingInfo {
         chainstate: &StacksChainState,
         tip_block_id: &StacksBlockId,
     ) -> Result<Self, ChainError> {
-        let first_block_mined = if !sn.sortition {
-            None
+        let (first_block_mined, nakamoto_blocks) = if !sn.sortition {
+            (None, None)
         } else {
             // is this a nakamoto sortition?
             let epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), sn.block_height)?.ok_or_else(
@@ -168,18 +171,28 @@ impl TenureForkingInfo {
                 },
             )?;
             if epoch.epoch_id < StacksEpochId::Epoch30 {
-                StacksChainState::get_stacks_block_header_info_by_consensus_hash(
-                    chainstate.db(),
-                    &sn.consensus_hash,
-                )?
-                .map(|header| header.index_block_hash())
+                (
+                    StacksChainState::get_stacks_block_header_info_by_consensus_hash(
+                        chainstate.db(),
+                        &sn.consensus_hash,
+                    )?
+                    .map(|header| header.index_block_hash()),
+                    None,
+                )
             } else {
-                NakamotoChainState::get_nakamoto_tenure_start_block_header(
-                    &mut chainstate.index_conn(),
-                    tip_block_id,
-                    &sn.consensus_hash,
-                )?
-                .map(|header| header.index_block_hash())
+                (
+                    NakamotoChainState::get_nakamoto_tenure_start_block_header(
+                        &mut chainstate.index_conn(),
+                        tip_block_id,
+                        &sn.consensus_hash,
+                    )?
+                    .map(|header| header.index_block_hash()),
+                    Some(
+                        chainstate
+                            .nakamoto_blocks_db()
+                            .get_nakamoto_blocks_in_tenure(&sn.consensus_hash)?,
+                    ),
+                )
             }
         };
         Ok(TenureForkingInfo {
@@ -190,6 +203,7 @@ impl TenureForkingInfo {
             consensus_hash: sn.consensus_hash.clone(),
             was_sortition: sn.sortition,
             first_block_mined,
+            nakamoto_blocks,
         })
     }
 }

stackslib/src/net/api/mod.rs

@@ -24,6 +24,7 @@ use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::HexError;
 
 use crate::burnchains::Txid;
+use crate::chainstate::nakamoto::NakamotoBlock;
 use crate::chainstate::stacks::{StacksMicroblock, StacksTransaction};
 use crate::core::mempool;
 use crate::cost_estimates::FeeRateEstimate;
@@ -225,6 +226,82 @@ pub mod prefix_hex {
     }
 }
 
+/// This module serde encode and decodes structs that
+/// implement StacksMessageCodec as a 0x-prefixed hex string.
+pub mod prefix_hex_codec {
+    use clarity::codec::StacksMessageCodec;
+    use clarity::util::hash::{hex_bytes, to_hex};
+
+    pub fn serialize<S: serde::Serializer, T: StacksMessageCodec>(
+        val: &T,
+        s: S,
+    ) -> Result<S::Ok, S::Error> {
+        let mut bytes = vec![];
+        val.consensus_serialize(&mut bytes)
+            .map_err(serde::ser::Error::custom)?;
+        s.serialize_str(&format!("0x{}", to_hex(&bytes)))
+    }
+
+    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: StacksMessageCodec>(
+        d: D,
+    ) -> Result<T, D::Error> {
+        let inst_str: String = serde::Deserialize::deserialize(d)?;
+        let Some(hex_str) = inst_str.get(2..) else {
+            return Err(serde::de::Error::invalid_length(
+                inst_str.len(),
+                &"at least length 2 string",
+            ));
+        };
+        let bytes = hex_bytes(hex_str).map_err(serde::de::Error::custom)?;
+        T::consensus_deserialize(&mut &bytes[..]).map_err(serde::de::Error::custom)
+    }
+}
+
+/// This module serde encode and decodes structs that
+/// implement StacksMessageCodec as a 0x-prefixed hex string.
+/// This is the same as prefix_hex_codec, but for Option<T>.
+pub mod prefix_opt_hex_codec {
+    use clarity::codec::StacksMessageCodec;
+    use clarity::util::hash::{hex_bytes, to_hex};
+
+    use super::prefix_hex_codec;
+
+    pub fn serialize<S: serde::Serializer, T: StacksMessageCodec>(
+        val: &Option<T>,
+        s: S,
+    ) -> Result<S::Ok, S::Error> {
+        match val {
+            Some(ref some_val) => {
+                let mut bytes = vec![];
+                some_val
+                    .consensus_serialize(&mut bytes)
+                    .map_err(serde::ser::Error::custom)?;
+                let hex_string = format!("0x{}", to_hex(&bytes));
+                s.serialize_some(&hex_string)
+            }
+            None => s.serialize_none(),
+        }
+    }
+
+    pub fn deserialize<'de, D: serde::Deserializer<'de>, T: StacksMessageCodec>(
+        d: D,
+    ) -> Result<Option<T>, D::Error> {
+        let opt_inst_str: Option<String> = serde::Deserialize::deserialize(d)?;
+        let Some(inst_string) = opt_inst_str else {
+            return Ok(None);
+        };
+        let Some(hex_str) = inst_string.get(2..) else {
+            return Err(serde::de::Error::invalid_length(
+                inst_string.len(),
+                &"at least length 2 string",
+            ));
+        };
+        let bytes = hex_bytes(hex_str).map_err(serde::de::Error::custom)?;
+        let val = T::consensus_deserialize(&mut &bytes[..]).map_err(serde::de::Error::custom)?;
+        Ok(Some(val))
+    }
+}
+
 pub trait HexDeser: Sized {
     fn try_from(hex: &str) -> Result<Self, HexError>;
 }