feat: Replace Chain Muxer with a simpler state-machine (#5322)

Author: David Himmelstrup

src/blocks/block.rs

@@ -14,13 +14,19 @@ pub const BLOCK_MESSAGE_LIMIT: usize = 10000;
 
 /// A complete Filecoin block. This contains the block header as well as all BLS
 /// and SECP messages.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Block {
     pub header: CachingBlockHeader,
     pub bls_messages: Vec<Message>,
     pub secp_messages: Vec<SignedMessage>,
 }
 
+impl std::hash::Hash for Block {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        std::hash::Hash::hash(self.cid(), state)
+    }
+}
+
 impl Block {
     pub fn header(&self) -> &CachingBlockHeader {
         &self.header

src/blocks/chain4u.rs

@@ -289,6 +289,24 @@ impl Chain4UInner {
         });
         header.state_root.close_with(Cid::default);
 
+        // Message root
+        ///////////////
+        header.messages.close_with(|| {
+            use crate::utils::db::CborStoreExt as _;
+            use fil_actors_shared::fvm_ipld_amt::Amtv0 as Amt;
+
+            let blockstore = MemoryDB::default();
+            let bls_message_root = Amt::<Cid, _>::new(&blockstore).flush().unwrap();
+            let secp_message_root = Amt::<Cid, _>::new(&blockstore).flush().unwrap();
+            let meta = TxMeta {
+                bls_message_root,
+                secp_message_root,
+            };
+
+            // Store message roots and receive meta_root CID
+            blockstore.put_cbor_default(&meta).unwrap()
+        });
+
         // Miner
         ////////
         let sibling_miner_addresses = siblings

src/blocks/header.rs

@@ -233,6 +233,8 @@ impl PartialEq for CachingBlockHeader {
     }
 }
 
+impl Eq for CachingBlockHeader {}
+
 impl Clone for CachingBlockHeader {
     fn clone(&self) -> Self {
         Self {

src/blocks/tipset.rs

@@ -67,6 +67,24 @@ impl TipsetKey {
     pub fn len(&self) -> usize {
         self.0.len()
     }
+
+    /// Terse representation of the tipset key.
+    /// `bafy2bzaceaqrqoasufr7gdwrbhvlfy2xmc4e5sdzekjgyha2kldxigu73gilo`
+    /// becomes `eaq...ilo`. The `bafy2bzac` prefix is removed.
+    pub fn terse(&self) -> String {
+        fn terse_cid(cid: Cid) -> String {
+            let s = cid::multibase::encode(
+                cid::multibase::Base::Base32Lower,
+                cid.to_bytes().as_slice(),
+            );
+            format!("{}...{}", &s[9..12], &s[s.len() - 3..])
+        }
+        self.to_cids()
+            .into_iter()
+            .map(terse_cid)
+            .collect::<Vec<_>>()
+            .join(", ")
+    }
 }
 
 impl From<NonEmpty<Cid>> for TipsetKey {
@@ -412,13 +430,19 @@ impl Tipset {
 
 /// `FullTipset` is an expanded version of a tipset that contains all the blocks
 /// and messages.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq)]
 pub struct FullTipset {
     blocks: NonEmpty<Block>,
     // key is lazily initialized via `fn key()`.
     key: OnceCell<TipsetKey>,
 }
 
+impl std::hash::Hash for FullTipset {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.key().hash(state)
+    }
+}
+
 // Constructing a FullTipset from a single Block is infallible.
 impl From<Block> for FullTipset {
     fn from(block: Block) -> Self {
@@ -480,6 +504,10 @@ impl FullTipset {
     pub fn parent_state(&self) -> &Cid {
         &self.first_block().header().state_root
     }
+    /// Returns the state root for the tipset parent.
+    pub fn parents(&self) -> &TipsetKey {
+        &self.first_block().header().parents
+    }
     /// Returns epoch of the tipset.
     pub fn epoch(&self) -> ChainEpoch {
         self.first_block().header().epoch

src/chain/store/chain_store.rs

@@ -6,7 +6,6 @@ use super::{
     tipset_tracker::TipsetTracker,
     Error,
 };
-use crate::db::{EthMappingsStore, EthMappingsStoreExt};
 use crate::fil_cns;
 use crate::interpreter::{BlockMessages, VMEvent, VMTrace};
 use crate::libp2p_bitswap::{BitswapStoreRead, BitswapStoreReadWrite};
@@ -24,6 +23,10 @@ use crate::{
     blocks::{CachingBlockHeader, Tipset, TipsetKey, TxMeta},
     db::HeaviestTipsetKeyProvider,
 };
+use crate::{
+    chain_sync::metrics,
+    db::{EthMappingsStore, EthMappingsStoreExt},
+};
 use ahash::{HashMap, HashMapExt, HashSet};
 use anyhow::Context as _;
 use cid::Cid;
@@ -36,7 +39,7 @@ use parking_lot::{Mutex, RwLock};
 use serde::{de::DeserializeOwned, Serialize};
 use std::{num::NonZeroUsize, sync::Arc};
 use tokio::sync::broadcast::{self, Sender as Publisher};
-use tracing::{debug, info, trace, warn};
+use tracing::{debug, trace, warn};
 
 // A cap on the size of the future_sink
 const SINK_CAP: usize = 200;
@@ -139,6 +142,7 @@ where
 
     /// Sets heaviest tipset
     pub fn set_heaviest_tipset(&self, ts: Arc<Tipset>) -> Result<(), Error> {
+        metrics::HEAD_EPOCH.set(ts.epoch());
         self.heaviest_tipset_key_provider
             .set_heaviest_tipset_key(ts.key())?;
         if self.publisher.send(HeadChange::Apply(ts)).is_err() {
@@ -255,7 +259,6 @@ where
         let curr_weight = heaviest_weight;
 
         if new_weight > curr_weight {
-            info!("New heaviest tipset! {} (EPOCH = {})", ts.key(), ts.epoch());
             self.set_heaviest_tipset(ts)?;
         }
         Ok(())

src/chain_sync/bad_block_cache.rs

@@ -8,6 +8,8 @@ use lru::LruCache;
 use nonzero_ext::nonzero;
 use parking_lot::Mutex;
 
+use crate::blocks::TipsetKey;
+
 /// Thread-safe cache for tracking bad blocks.
 /// This cache is checked before validating a block, to ensure no duplicate
 /// work.
@@ -34,15 +36,21 @@ impl BadBlockCache {
         self.cache.lock().put(c, reason)
     }
 
-    /// Returns `Some` with the reason if the block CID is in bad block cache.
-    /// This also updates the key to the head of the cache.
-    pub fn get(&self, c: &Cid) -> Option<String> {
-        self.cache.lock().get(c).cloned()
-    }
-
     /// Returns `Some` with the reason if the block CID is in bad block cache.
     /// This function does not update the head position of the `Cid` key.
     pub fn peek(&self, c: &Cid) -> Option<String> {
         self.cache.lock().peek(c).cloned()
     }
+
+    /// Returns `Some` with the reason if there are any known bad blocks in the tipset.
+    /// This function does not update the head position of the `Cid` key.
+    pub fn peek_tipset_key(&self, tipset_key: &TipsetKey) -> Option<String> {
+        let cache = self.cache.lock();
+        for block in tipset_key.iter() {
+            if let Some(reason) = cache.peek(&block) {
+                return Some(reason.clone());
+            }
+        }
+        None
+    }
 }