feat: implement optimized vector of CIDs

.config/forest.dic

@@ -55,6 +55,7 @@ milliGas
 multihash
 multisig
 mutex
+overallocation
 P2P
 parsable
 pointer/SM

src/blocks/tipset.rs

@@ -3,6 +3,7 @@
 
 use std::{fmt, sync::OnceLock};
 
+use crate::ipld::FrozenCids;
 use crate::networks::{calibnet, mainnet};
 use crate::shim::{address::Address, clock::ChainEpoch};
 use crate::utils::cid::CidCborExt;
@@ -26,35 +27,36 @@ use super::{Block, BlockHeader, Error, Ticket};
 #[cfg_attr(test, derive(derive_quickcheck_arbitrary::Arbitrary))]
 #[serde(transparent)]
 pub struct TipsetKeys {
-    pub cids: Vec<Cid>,
+    pub cids: FrozenCids,
 }
 
 impl TipsetKeys {
-    pub fn new(cids: Vec<Cid>) -> Self {
+    pub fn new(cids: FrozenCids) -> Self {
         Self { cids }
     }
 
-    /// Returns tipset header `cids`
-    pub fn cids(&self) -> &[Cid] {
-        &self.cids
-    }
-
     // Special encoding to match Lotus.
     pub fn cid(&self) -> anyhow::Result<Cid> {
         use fvm_ipld_encoding::RawBytes;
         let mut bytes = Vec::new();
-        for cid in self.cids() {
+        for cid in &self.cids {
             bytes.append(&mut cid.to_bytes())
         }
         Ok(Cid::from_cbor_blake2b256(&RawBytes::new(bytes))?)
     }
 }
 
+impl From<Vec<Cid>> for TipsetKeys {
+    fn from(cids: Vec<Cid>) -> Self {
+        Self::new(FrozenCids::from(cids))
+    }
+}
+
 impl fmt::Display for TipsetKeys {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let s = self
-            .cids()
-            .iter()
+            .cids
+            .into_iter()
             .map(|cid| cid.to_string())
             .collect::<Vec<_>>()
             .join(", ");
@@ -141,9 +143,9 @@ impl Tipset {
     /// present but invalid. If the tipset is missing, None is returned.
     pub fn load(store: impl Blockstore, tsk: &TipsetKeys) -> anyhow::Result<Option<Tipset>> {
         Ok(tsk
-            .cids()
-            .iter()
-            .map(|key| BlockHeader::load(&store, *key))
+            .cids
+            .into_iter()
+            .map(|key| BlockHeader::load(&store, key))
             .collect::<anyhow::Result<Option<_>>>()?
             .map(Tipset::new)
             .transpose()?)
@@ -220,8 +222,8 @@ impl Tipset {
         })
     }
     /// Returns slice of `CIDs` for the current tipset
-    pub fn cids(&self) -> &[Cid] {
-        self.key().cids()
+    pub fn cids(&self) -> Vec<Cid> {
+        Vec::<Cid>::from(&self.key().cids)
     }
     /// Returns the keys of the parents of the blocks in the tipset.
     pub fn parents(&self) -> &TipsetKeys {
@@ -447,15 +449,15 @@ pub mod tipset_keys_json {
     where
         S: Serializer,
     {
-        crate::json::cid::vec::serialize(m.cids(), serializer)
+        crate::json::cid::vec::serialize(&Vec::<Cid>::from(&m.cids), serializer)
     }
 
     pub fn deserialize<'de, D>(deserializer: D) -> Result<TipsetKeys, D::Error>
     where
         D: Deserializer<'de>,
     {
         Ok(TipsetKeys {
-            cids: crate::json::cid::vec::deserialize(deserializer)?,
+            cids: crate::json::cid::vec::deserialize(deserializer)?.into(),
         })
     }
 }
@@ -563,6 +565,7 @@ mod property_tests {
 #[cfg(test)]
 mod test {
     use crate::blocks::VRFProof;
+    use crate::ipld::FrozenCids;
     use crate::shim::address::Address;
     use cid::{
         multihash::{Code::Identity, MultihashDigest},
@@ -712,10 +715,10 @@ mod test {
             .unwrap();
         let h1 = BlockHeader::builder()
             .miner_address(Address::new_id(1))
-            .parents(TipsetKeys::new(vec![Cid::new_v1(
+            .parents(TipsetKeys::new(FrozenCids::from_iter([Cid::new_v1(
                 DAG_CBOR,
                 Identity.digest(&[]),
-            )]))
+            )])))
             .build()
             .unwrap();
         assert_eq!(

src/chain/mod.rs

@@ -8,6 +8,7 @@ use crate::ipld::{stream_chain, CidHashSet};
 use crate::utils::io::{AsyncWriterWithChecksum, Checksum};
 use crate::utils::stream::par_buffer;
 use anyhow::{Context, Result};
+use cid::Cid;
 use digest::Digest;
 use fvm_ipld_blockstore::Blockstore;
 use std::sync::Arc;
@@ -25,7 +26,7 @@ pub async fn export<D: Digest>(
 ) -> Result<Option<digest::Output<D>>, Error> {
     let db = Arc::new(db);
     let stateroot_lookup_limit = tipset.epoch() - lookup_depth;
-    let roots = tipset.key().cids().to_vec();
+    let roots = Vec::<Cid>::from(&tipset.key().cids);
 
     // Wrap writer in optional checksum calculator
     let mut writer = AsyncWriterWithChecksum::<D, _>::new(BufWriter::new(writer), !skip_checksum);

src/chain/store/chain_store.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 
 use crate::blocks::{BlockHeader, Tipset, TipsetKeys, TxMeta};
 use crate::interpreter::BlockMessages;
+use crate::ipld::FrozenCids;
 use crate::libp2p_bitswap::{BitswapStoreRead, BitswapStoreReadWrite};
 use crate::message::{ChainMessage, Message as MessageTrait, SignedMessage};
 use crate::networks::ChainConfig;
@@ -114,7 +115,7 @@ where
             .read_obj::<TipsetKeys>(HEAD_KEY)?
             .is_some_and(|tipset_keys| chain_index.load_tipset(&tipset_keys).is_ok())
         {
-            let tipset_keys = TipsetKeys::new(vec![*genesis_block_header.cid()]);
+            let tipset_keys = TipsetKeys::new(FrozenCids::from_iter([*genesis_block_header.cid()]));
             settings.write_obj(HEAD_KEY, &tipset_keys)?;
         }
 
@@ -206,7 +207,7 @@ where
     /// Returns Tipset from key-value store from provided CIDs
     #[tracing::instrument(skip_all)]
     pub fn tipset_from_keys(&self, tsk: &TipsetKeys) -> Result<Arc<Tipset>, Error> {
-        if tsk.cids().is_empty() {
+        if tsk.cids.is_empty() {
             return Ok(self.heaviest_tipset());
         }
         self.chain_index.load_tipset(tsk)

src/chain_sync/chain_muxer.rs

@@ -259,7 +259,7 @@ where
         if network.peer_manager().is_peer_new(&peer_id).await {
             // Since the peer is new, send them a hello request
             let request = HelloRequest {
-                heaviest_tip_set: heaviest.cids().to_vec(),
+                heaviest_tip_set: heaviest.cids(),
                 heaviest_tipset_height: heaviest.epoch(),
                 heaviest_tipset_weight: heaviest.weight().clone().into(),
                 genesis_cid: genesis_block_cid,
@@ -372,7 +372,7 @@ where
                 metrics::LIBP2P_MESSAGE_TOTAL
                     .with_label_values(&[metrics::values::HELLO_RESPONSE_OUTBOUND])
                     .inc();
-                let tipset_keys = TipsetKeys::new(request.heaviest_tip_set);
+                let tipset_keys = TipsetKeys::from(request.heaviest_tip_set);
                 let tipset = match Self::get_full_tipset(
                     network.clone(),
                     chain_store.clone(),

src/chain_sync/network_context.rs

@@ -225,7 +225,7 @@ where
         T: TryFrom<TipsetBundle, Error = String> + Send + Sync + 'static,
     {
         let request = ChainExchangeRequest {
-            start: tsk.cids().to_vec(),
+            start: Vec::<Cid>::from(&tsk.cids),
             request_len,
             options,
         };

src/chain_sync/tipset_syncer.rs

@@ -882,7 +882,7 @@ async fn sync_headers_in_reverse<DB: Blockstore + Sync + Send + 'static, C: Cons
         }
         // Attempt to load the parent tipset from local store
         if let Ok(tipset) = chain_store.tipset_from_keys(oldest_parent.parents()) {
-            parent_blocks.extend_from_slice(tipset.cids());
+            parent_blocks.extend(tipset.cids());
             parent_tipsets.push(tipset);
             continue;
         }
@@ -901,7 +901,7 @@ async fn sync_headers_in_reverse<DB: Blockstore + Sync + Send + 'static, C: Cons
                 break 'sync;
             }
             validate_tipset_against_cache(bad_block_cache, tipset.key(), &parent_blocks)?;
-            parent_blocks.extend_from_slice(tipset.cids());
+            parent_blocks.extend(tipset.cids());
             tracker.write().set_epoch(tipset.epoch());
             parent_tipsets.push(tipset);
         }
@@ -936,7 +936,7 @@ async fn sync_headers_in_reverse<DB: Blockstore + Sync + Send + 'static, C: Cons
                 // iterator is immediately dropped
                 let mut fork_tipsets = fork_tipsets;
                 fork_tipsets.drain((i + 1)..);
-                parent_tipsets.extend_from_slice(&fork_tipsets);
+                parent_tipsets.extend(fork_tipsets);
                 break;
             }
 
@@ -1593,14 +1593,12 @@ fn validate_tipset_against_cache<C: Consensus>(
     tipset: &TipsetKeys,
     descendant_blocks: &[Cid],
 ) -> Result<(), TipsetRangeSyncerError<C>> {
-    for cid in tipset.cids() {
-        if let Some(reason) = bad_block_cache.get(cid) {
+    for cid in &tipset.cids {
+        if let Some(reason) = bad_block_cache.get(&cid) {
             for block_cid in descendant_blocks {
                 bad_block_cache.put(*block_cid, format!("chain contained {cid}"));
             }
-            return Err(TipsetRangeSyncerError::TipsetRangeWithBadBlock(
-                *cid, reason,
-            ));
+            return Err(TipsetRangeSyncerError::TipsetRangeWithBadBlock(cid, reason));
         }
     }
     Ok(())

src/cli/subcommands/chain_cmd.rs

@@ -91,12 +91,9 @@ impl ChainCommands {
                 force: no_confirm,
             } => {
                 maybe_confirm(*no_confirm, SET_HEAD_CONFIRMATION_MESSAGE)?;
-                chain_set_head(
-                    (TipsetKeys { cids: cids.clone() },),
-                    &config.client.rpc_token,
-                )
-                .await
-                .map_err(handle_rpc_err)
+                chain_set_head((TipsetKeys::from(cids.clone()),), &config.client.rpc_token)
+                    .await
+                    .map_err(handle_rpc_err)
             }
         }
     }

src/db/car/forest.rs

@@ -132,7 +132,7 @@ impl<ReaderT: super::RandomAccessFileReader> ForestCar<ReaderT> {
     }
 
     pub fn heaviest_tipset(&self) -> anyhow::Result<Tipset> {
-        Tipset::load_required(self, &TipsetKeys::new(self.roots()))
+        Tipset::load_required(self, &TipsetKeys::from(self.roots()))
     }
 
     pub fn into_dyn(self) -> ForestCar<Box<dyn super::RandomAccessFileReader>> {

src/db/car/plain.rs

@@ -156,7 +156,7 @@ impl<ReaderT: super::RandomAccessFileReader> PlainCar<ReaderT> {
     }
 
     pub fn heaviest_tipset(&self) -> anyhow::Result<Tipset> {
-        Tipset::load_required(self, &TipsetKeys::new(self.roots()))
+        Tipset::load_required(self, &TipsetKeys::from(self.roots()))
     }
 
     /// In an arbitrary order

src/genesis/mod.rs

@@ -117,7 +117,7 @@ where
         sm.chain_store().set_estimated_records(n_records as u64)?;
     }
 
-    let ts = sm.chain_store().tipset_from_keys(&TipsetKeys::new(cids))?;
+    let ts = sm.chain_store().tipset_from_keys(&TipsetKeys::from(cids))?;
 
     if !skip_load {
         let gb = sm.chain_store().chain_index.tipset_by_height(

src/interpreter/fvm2.rs

@@ -221,8 +221,8 @@ impl<DB: Blockstore + Send + Sync + 'static> Consensus for ForestExternsV2<DB> {
             let bh_3 = from_slice_with_fallback::<BlockHeader>(extra)?;
             if bh_1.parents() == bh_3.parents()
                 && bh_1.epoch() == bh_3.epoch()
-                && bh_2.parents().cids().contains(bh_3.cid())
-                && !bh_2.parents().cids().contains(bh_1.cid())
+                && bh_2.parents().cids.contains(*bh_3.cid())
+                && !bh_2.parents().cids.contains(*bh_1.cid())
             {
                 fault_type = Some(ConsensusFaultType::ParentGrinding);
             }

src/interpreter/fvm3.rs

@@ -242,8 +242,8 @@ impl<DB: Blockstore + Send + Sync + 'static> Consensus for ForestExterns<DB> {
             let bh_3 = from_slice_with_fallback::<BlockHeader>(extra)?;
             if bh_1.parents() == bh_3.parents()
                 && bh_1.epoch() == bh_3.epoch()
-                && bh_2.parents().cids().contains(bh_3.cid())
-                && !bh_2.parents().cids().contains(bh_1.cid())
+                && bh_2.parents().cids.contains(*bh_3.cid())
+                && !bh_2.parents().cids.contains(*bh_1.cid())
             {
                 fault_type = Some(ConsensusFaultType::ParentGrinding);
             }

src/ipld/cid_hashmap.rs

@@ -33,32 +33,30 @@ impl<V> CidHashMap<V> {
 
     /// Returns `true` if the map contains a value for the specified key.
     pub fn contains_key(&self, k: Cid) -> bool {
-        match k.try_into() {
-            Ok(CidVariant::V1DagCborBlake2b(bytes)) => {
+        match k.into() {
+            CidVariant::V1DagCborBlake2b(bytes) => {
                 self.v1_dagcbor_blake2b_hash_map.contains_key(&bytes)
             }
-            Err(()) => self.fallback_hash_map.contains_key(&k),
+            CidVariant::Generic(_) => self.fallback_hash_map.contains_key(&k),
         }
     }
 
     /// Inserts a key-value pair into the map; if the map did not have this key present, [`None`] is returned.
     pub fn insert(&mut self, k: Cid, v: V) -> Option<V> {
-        match k.try_into() {
-            Ok(CidVariant::V1DagCborBlake2b(bytes)) => {
+        match k.into() {
+            CidVariant::V1DagCborBlake2b(bytes) => {
                 self.v1_dagcbor_blake2b_hash_map.insert(bytes, v)
             }
-            Err(()) => self.fallback_hash_map.insert(k, v),
+            CidVariant::Generic(_) => self.fallback_hash_map.insert(k, v),
         }
     }
 
     /// Removes a key from the map, returning the value at the key if the key
     /// was previously in the map.
     pub fn remove(&mut self, k: Cid) -> Option<V> {
-        match k.try_into() {
-            Ok(CidVariant::V1DagCborBlake2b(bytes)) => {
-                self.v1_dagcbor_blake2b_hash_map.remove(&bytes)
-            }
-            Err(()) => self.fallback_hash_map.remove(&k),
+        match k.into() {
+            CidVariant::V1DagCborBlake2b(bytes) => self.v1_dagcbor_blake2b_hash_map.remove(&bytes),
+            CidVariant::Generic(_) => self.fallback_hash_map.remove(&k),
         }
     }
 
@@ -69,9 +67,9 @@ impl<V> CidHashMap<V> {
 
     /// Returns a reference to the value corresponding to the key.
     pub fn get(&self, k: Cid) -> Option<&V> {
-        match k.try_into() {
-            Ok(CidVariant::V1DagCborBlake2b(bytes)) => self.v1_dagcbor_blake2b_hash_map.get(&bytes),
-            Err(()) => self.fallback_hash_map.get(&k),
+        match k.into() {
+            CidVariant::V1DagCborBlake2b(bytes) => self.v1_dagcbor_blake2b_hash_map.get(&bytes),
+            CidVariant::Generic(_) => self.fallback_hash_map.get(&k),
         }
     }