fix: optimize logic of looking up genesis from a tipset (#7290)

Author: hanabi1224

src/beacon/mock_beacon.rs

@@ -3,6 +3,7 @@
 
 use super::DrandNetwork;
 use crate::beacon::{Beacon, BeaconEntry};
+use crate::prelude::*;
 use crate::shim::version::NetworkVersion;
 use crate::utils::encoding::blake2b_256;
 use byteorder::{BigEndian, ByteOrder};
@@ -45,7 +46,11 @@ impl Beacon for MockBeacon {
         Ok(Self::entry_for_index(round))
     }
 
-    fn max_beacon_round_for_epoch(&self, _network_version: NetworkVersion, fil_epoch: i64) -> u64 {
+    fn max_beacon_round_for_epoch(
+        &self,
+        _network_version: NetworkVersion,
+        fil_epoch: ChainEpoch,
+    ) -> u64 {
         fil_epoch as u64
     }
 }

src/blocks/tipset.rs

@@ -3,7 +3,7 @@
 
 use std::{
     fmt,
-    sync::{Arc, LazyLock, OnceLock},
+    sync::{LazyLock, OnceLock},
 };
 
 use super::{Block, CachingBlockHeader, RawBlockHeader, Ticket};
@@ -12,7 +12,6 @@ use crate::{
     cid_collections::SmallCidNonEmptyVec,
     networks::{calibnet, mainnet},
     prelude::*,
-    shim::clock::ChainEpoch,
     utils::{
         cid::CidCborExt,
         db::{CborStoreExt, car_stream::CarBlock},
@@ -195,6 +194,12 @@ impl get_size2::GetSize for Tipset {
     }
 }
 
+impl From<&RawBlockHeader> for Tipset {
+    fn from(value: &RawBlockHeader) -> Self {
+        value.clone().into()
+    }
+}
+
 impl From<RawBlockHeader> for Tipset {
     fn from(value: RawBlockHeader) -> Self {
         Self::from(CachingBlockHeader::from(value))
@@ -421,8 +426,19 @@ impl Tipset {
         })
     }
 
-    /// Fetch the genesis block header for a given tipset.
-    pub fn genesis(&self, store: &impl Blockstore) -> anyhow::Result<CachingBlockHeader> {
+    /// Fetch the genesis tipset for a given tipset.
+    pub async fn genesis(
+        &self,
+        store: impl Blockstore + Send + Sync + 'static,
+    ) -> anyhow::Result<Tipset> {
+        let this = self.shallow_clone();
+        tokio::task::spawn_blocking(move || this.genesis_blocking(&store)).await?
+    }
+
+    /// Fetch the genesis tipset for a given tipset.
+    /// This call can be expensive and blocking, use [`Self::genesis`]
+    /// in async contexts to avoid exhausting Tokio worker threads.
+    pub fn genesis_blocking(&self, store: &impl Blockstore) -> anyhow::Result<Tipset> {
         // Scanning through millions of epochs to find the genesis is quite
         // slow. Let's use a list of known blocks to short-circuit the search.
         // The blocks are hash-chained together and known blocks are guaranteed
@@ -438,7 +454,7 @@ impl Tipset {
             serde_yaml::from_str(include_str!("../../build/known_blocks.yaml")).unwrap()
         });
 
-        for tipset in self.clone().chain(store) {
+        for tipset in self.shallow_clone().chain(store) {
             // Search for known calibnet and mainnet blocks
             for (genesis_cid, known_blocks) in [
                 (*calibnet::GENESIS_CID, &headers.calibnet),
@@ -447,15 +463,16 @@ impl Tipset {
                 if let Some(known_block_cid) = known_blocks.get(&tipset.epoch())
                     && known_block_cid == &tipset.min_ticket_block().cid().to_string()
                 {
-                    return store
+                    let genesis_block: CachingBlockHeader = store
                         .get_cbor(&genesis_cid)?
-                        .context("Genesis block missing from database");
+                        .context("Genesis block missing from database")?;
+                    return Ok(genesis_block.into());
                 }
             }
 
             // If no known blocks are found, we'll eventually hit the genesis tipset.
             if tipset.epoch() == 0 {
-                return Ok(tipset.min_ticket_block().clone());
+                return Ok(tipset);
             }
         }
         anyhow::bail!("Genesis block not found")
@@ -633,14 +650,13 @@ mod lotus_json {
     //! [Tipset] isn't just plain old data - it has an invariant (all block headers are valid)
     //! So there is custom de-serialization here
 
+    use super::*;
     use crate::blocks::{CachingBlockHeader, Tipset};
     use crate::lotus_json::*;
     use nunny::Vec as NonEmpty;
     use schemars::JsonSchema;
     use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error as _};
 
-    use super::TipsetKey;
-
     #[derive(Debug, PartialEq, Clone, JsonSchema)]
     #[schemars(rename = "Tipset")]
     pub struct TipsetLotusJson(#[schemars(with = "TipsetLotusJsonInner")] Tipset);
@@ -655,7 +671,7 @@ mod lotus_json {
         #[serde(with = "crate::lotus_json")]
         #[schemars(with = "LotusJson<NonEmpty<CachingBlockHeader>>")]
         blocks: NonEmpty<CachingBlockHeader>,
-        height: i64,
+        height: ChainEpoch,
     }
 
     impl<'de> Deserialize<'de> for TipsetLotusJson {

src/chain/ec_finality/calculator/mod.rs

@@ -18,7 +18,7 @@ mod skellam;
 #[cfg(test)]
 mod tests;
 
-use anyhow::Context as _;
+use crate::prelude::*;
 use std::sync::LazyLock;
 
 // `BISECT_LOW` and `BISECT_HIGH` define the search range for the bisect algorithm
@@ -46,11 +46,11 @@ pub static DEFAULT_GUARANTEE: LazyLock<f64> =
 #[allow(dead_code)]
 pub fn calc_validator_prob(
     chain: &[i64],
-    finality: i64,
+    finality: ChainEpoch,
     blocks_per_epoch: f64,
     byzantine_fraction: f64,
-    current_epoch: i64,
-    target_epoch: i64,
+    current_epoch: ChainEpoch,
+    target_epoch: ChainEpoch,
 ) -> anyhow::Result<f64> {
     if current_epoch <= target_epoch || target_epoch < 0 || current_epoch >= chain.len() as i64 {
         return Ok(1.0);

src/chain/store/chain_store.rs

@@ -78,7 +78,8 @@ pub struct ChainStore {
     /// Tracks blocks for the purpose of forming tipsets.
     tipset_tracker: TipsetTracker<DbImpl>,
 
-    genesis_block_header: Arc<CachingBlockHeader>,
+    /// Genesis tipset.
+    genesis: Tipset,
 
     /// validated blocks
     pub(crate) validated_blocks: SizeTrackingCache<CidWrapper, ()>,
@@ -99,7 +100,7 @@ impl ShallowClone for ChainStore {
             ec_calculator_finalized_epoch: self.ec_calculator_finalized_epoch.shallow_clone(),
             chain_index: self.chain_index.shallow_clone(),
             tipset_tracker: self.tipset_tracker.shallow_clone(),
-            genesis_block_header: self.genesis_block_header.shallow_clone(),
+            genesis: self.genesis.shallow_clone(),
             validated_blocks: self.validated_blocks.shallow_clone(),
             chain_config: self.chain_config.shallow_clone(),
             messages_in_tipset_cache: self.messages_in_tipset_cache.shallow_clone(),
@@ -111,9 +112,11 @@ impl ChainStore {
     pub fn new(
         db: impl Into<DbImpl>,
         chain_config: Arc<ChainConfig>,
-        genesis_block_header: CachingBlockHeader,
+        genesis: impl Into<Tipset>,
     ) -> anyhow::Result<Self> {
         let db = db.into();
+        let genesis = genesis.into();
+        anyhow::ensure!(genesis.epoch() == 0, "genesis tipset must be at epoch 0");
         let (publisher, _) = broadcast::channel(SINK_CAP);
         let head = if let Some(head_tsk) = db
             .heaviest_tipset_key()
@@ -122,11 +125,11 @@ impl ChainStore {
             Tipset::load_required(&db, &head_tsk)
                 .with_context(|| format!("failed to load head tipset with key {head_tsk}"))?
         } else {
-            Tipset::from(&genesis_block_header)
+            genesis.shallow_clone()
         };
         let heaviest_tipset = Arc::new(ArcSwap::from_pointee(head.shallow_clone()));
         let f3_finalized_tipset: Arc<ArcSwapOption<Tipset>> = Default::default();
-        let chain_index = ChainIndex::new(db.shallow_clone());
+        let chain_index = ChainIndex::new(db.shallow_clone(), genesis.shallow_clone());
         let ec_calculator_finalized_epoch = Arc::new(AtomicI64::new(
             ChainGetTipSetFinalityStatus::get_ec_finality_epoch(&chain_index, &chain_config, &head),
         ));
@@ -150,7 +153,7 @@ impl ChainStore {
             heaviest_tipset,
             f3_finalized_tipset,
             ec_calculator_finalized_epoch,
-            genesis_block_header: genesis_block_header.into(),
+            genesis,
             validated_blocks: SizeTrackingCache::new_with_metrics(
                 "validated_blocks",
                 VALIDATED_BLOCKS_CACHE_SIZE,
@@ -259,20 +262,21 @@ impl ChainStore {
         self.tipset_tracker.expand(header)
     }
 
+    /// Returns the genesis block header.
     pub fn genesis_block_header(&self) -> &CachingBlockHeader {
-        &self.genesis_block_header
+        self.genesis.min_ticket_block()
+    }
+
+    /// Returns the genesis tipset.
+    pub fn genesis_tipset(&self) -> Tipset {
+        self.genesis.shallow_clone()
     }
 
     /// Returns the currently tracked heaviest tipset.
     pub fn heaviest_tipset(&self) -> Tipset {
         self.heaviest_tipset.load().as_ref().shallow_clone()
     }
 
-    /// Returns the genesis tipset.
-    pub fn genesis_tipset(&self) -> Tipset {
-        Tipset::from(self.genesis_block_header())
-    }
-
     /// Subscribes head changes.
     pub fn subscribe_head_changes(&self) -> broadcast::Receiver<HeadChanges> {
         self.head_changes_tx.subscribe()
@@ -407,13 +411,10 @@ impl ChainStore {
 
         // More null blocks than lookback
         if lbr >= heaviest_tipset.epoch() {
-            // This situation is extremely rare so it's fine to compute the
-            // state-root without caching.
-            let genesis_timestamp = heaviest_tipset.genesis(chain_index.db())?.timestamp;
+            let genesis_timestamp = chain_index.genesis().min_ticket_block().timestamp;
             let beacon = Arc::new(chain_config.get_beacon_schedule(genesis_timestamp));
             let ExecutedTipset { state_root, .. } =
                 crate::state_manager::apply_block_messages_blocking(
-                    genesis_timestamp,
                     chain_index.shallow_clone(),
                     chain_config.shallow_clone(),
                     beacon,
@@ -726,14 +727,16 @@ mod tests {
         let gen_block = CachingBlockHeader::new(RawBlockHeader {
             miner_address: Address::new_id(0),
             state_root: Cid::new_v1(DAG_CBOR, MultihashCode::Identity.digest(&[])),
-            epoch: 1,
+            epoch: 0,
             weight: 2u32.into(),
             messages: Cid::new_v1(DAG_CBOR, MultihashCode::Identity.digest(&[])),
             message_receipts: Cid::new_v1(DAG_CBOR, MultihashCode::Identity.digest(&[])),
             ..Default::default()
         });
-        let cs = ChainStore::new(db, chain_config, gen_block.clone()).unwrap();
+        let gen_ts = Tipset::from(&gen_block);
+        let cs = ChainStore::new(db, chain_config, gen_ts.shallow_clone()).unwrap();
 
+        assert_eq!(cs.genesis_tipset(), gen_ts);
         assert_eq!(cs.genesis_block_header(), &gen_block);
     }
 

src/chain/store/index.rs

@@ -26,6 +26,8 @@ pub struct ChainIndex {
     ts_cache: TipsetCache,
     /// `Blockstore` pointer needed to load tipsets from cold storage.
     db: DbImpl,
+    /// Genesis tipset
+    genesis: Tipset,
     /// check whether a tipset is finalized
     is_tipset_finalized: Option<IsTipsetFinalizedFn>,
 }
@@ -35,6 +37,7 @@ impl ShallowClone for ChainIndex {
         Self {
             ts_cache: self.ts_cache.shallow_clone(),
             db: self.db.shallow_clone(),
+            genesis: self.genesis.shallow_clone(),
             is_tipset_finalized: self.is_tipset_finalized.clone(),
         }
     }
@@ -52,12 +55,14 @@ pub enum ResolveNullTipset {
 }
 
 impl ChainIndex {
-    pub fn new(db: impl Into<DbImpl>) -> Self {
+    pub fn new(db: impl Into<DbImpl>, genesis: Tipset) -> Self {
+        assert!(genesis.epoch() == 0, "genesis tipset must be at epoch 0");
         let db = db.into();
         let ts_cache = SizeTrackingCache::new_with_metrics("tipset", DEFAULT_TIPSET_CACHE_SIZE);
         Self {
             ts_cache,
             db,
+            genesis,
             is_tipset_finalized: None,
         }
     }
@@ -75,6 +80,10 @@ impl ChainIndex {
         self.db().shallow_clone()
     }
 
+    pub fn genesis(&self) -> &Tipset {
+        &self.genesis
+    }
+
     /// Loads a tipset from memory given the tipset keys and cache. Semantically
     /// identical to [`Tipset::load`] but the result is cached.
     pub fn load_tipset(&self, tsk: &TipsetKey) -> Result<Option<Tipset>, Error> {
@@ -169,7 +178,7 @@ impl ChainIndex {
         }
 
         if to == 0 {
-            return Ok(Some(Tipset::from(from.genesis(&self.db)?)));
+            return Ok(Some(self.genesis.shallow_clone()));
         }
 
         let from_epoch = from.epoch();
@@ -327,7 +336,7 @@ mod tests {
         persist_tipset(&epoch3, &db);
         persist_tipset(&epoch4, &db);
 
-        let index = ChainIndex::new(db);
+        let index = ChainIndex::new(db, genesis);
         // epoch 2 is null. ResolveNullTipset decided whether to return epoch 1 or epoch 3
         assert_eq!(
             index
@@ -365,7 +374,7 @@ mod tests {
         persist_tipset(&epoch2b, &db);
         persist_tipset(&epoch3b, &db);
 
-        let index = ChainIndex::new(db);
+        let index = ChainIndex::new(db, genesis);
         // The chain as forked, epoch 2 and 3 are ambiguous
         assert_eq!(
             index
@@ -394,7 +403,7 @@ mod tests {
         persist_tipset(&genesis, &db);
         persist_tipset(&epoch3, &db);
 
-        let index = ChainIndex::new(db);
+        let index = ChainIndex::new(db, genesis);
         assert!(
             index
                 .tipset_by_height(2, epoch3, ResolveNullTipset::TakeOlder)

src/chain_sync/chain_follower.rs

@@ -1168,7 +1168,7 @@ mod tests {
             [genesis_header = dummy_node(&db, 0)]
         };
 
-        let cs = ChainStore::new(db, Default::default(), genesis_header.clone().into()).unwrap();
+        let cs = ChainStore::new(db, Default::default(), genesis_header).unwrap();
 
         cs.set_heaviest_tipset(cs.genesis_tipset()).unwrap();
 

src/cli/subcommands/info_cmd.rs

@@ -182,6 +182,7 @@ impl InfoCommand {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::blocks::RawBlockHeader;
     use crate::blocks::{CachingBlockHeader, Tipset};
     use crate::shim::clock::EPOCH_DURATION_SECONDS;
@@ -190,8 +191,6 @@ mod tests {
     use quickcheck_macros::quickcheck;
     use std::{str::FromStr, time::Duration};
 
-    use super::{NodeStatusInfo, SyncStatus};
-
     fn mock_tipset_at(seconds_since_unix_epoch: u64) -> Tipset {
         CachingBlockHeader::new(RawBlockHeader {
             miner_address: Address::from_str("f2kmbjvz7vagl2z6pfrbjoggrkjofxspp7cqtw2zy").unwrap(),
@@ -205,7 +204,7 @@ mod tests {
         NodeStatusInfo {
             lag: 0,
             health: 90.,
-            epoch: i64::MAX,
+            epoch: ChainEpoch::MAX,
             base_fee: TokenAmount::from_whole(1),
             sync_status: SyncStatus::Ok,
             start_time: DateTime::<chrono::Utc>::MIN_UTC,