Struct forest_filecoin::chain::store::chain_store::ChainStore

pub struct ChainStore<DB> {
    publisher: Sender<HeadChange>,
    pub db: Arc<DB>,
    settings: Arc<dyn SettingsStore + Sync + Send>,
    pub chain_index: Arc<ChainIndex<Arc<DB>>>,
    tipset_tracker: TipsetTracker<DB>,
    genesis_block_header: CachingBlockHeader,
    validated_blocks: Mutex<HashSet<Cid>>,
    eth_mappings: Arc<dyn EthMappingsStore + Sync + Send>,
    pub chain_config: Arc<ChainConfig>,
}

Stores chain data such as heaviest tipset and cached tipset info at each epoch. This structure is thread-safe, and all caches are wrapped in a mutex to allow a consistent ChainStore to be shared across tasks.

Fields

publisher: Sender<HeadChange>

Publisher for head change events

db: Arc<DB>

key-value datastore.

settings: Arc<dyn SettingsStore + Sync + Send>

Settings store

chain_index: Arc<ChainIndex<Arc<DB>>>

Used as a cache for tipset lookbacks.

tipset_tracker: TipsetTracker<DB>

Tracks blocks for the purpose of forming tipsets.

genesis_block_header: CachingBlockHeader

validated_blocks: Mutex<HashSet<Cid>>

validated blocks

eth_mappings: Arc<dyn EthMappingsStore + Sync + Send>

Ethereum mappings store

chain_config: Arc<ChainConfig>

Needed by the Ethereum mapping.

Implementations

impl<DB> ChainStore<DB>

where DB: Blockstore,

pub fn new( db: Arc<DB>, settings: Arc<dyn SettingsStore + Sync + Send>, eth_mappings: Arc<dyn EthMappingsStore + Sync + Send>, chain_config: Arc<ChainConfig>, genesis_block_header: CachingBlockHeader, ) -> Result<Self>

pub fn set_heaviest_tipset(&self, ts: Arc<Tipset>) -> Result<(), Error>

Sets heaviest tipset within ChainStore and store its tipset keys in the settings store under the crate::db::setting_keys::HEAD_KEY key.

pub fn add_to_tipset_tracker(&self, header: &CachingBlockHeader)

Adds a block header to the tipset tracker, which tracks valid headers.

pub fn put_tipset(&self, ts: &Tipset) -> Result<(), Error>

Writes tipset block headers to data store and updates heaviest tipset with other compatible tracked headers.

pub fn put_tipset_key(&self, tsk: &TipsetKey) -> Result<(), Error>

Writes the TipsetKey to the blockstore for EthAPI queries.

pub fn put_delegated_message_hashes<'a>( &self, headers: impl Iterator<Item = &'a CachingBlockHeader>, ) -> Result<(), Error>

Writes the delegated message Cids to the blockstore for EthAPI queries.

pub fn get_required_tipset_key( &self, hash: &EthHash, ) -> Result<TipsetKey, Error>

Reads the TipsetKey from the blockstore for EthAPI queries.

pub fn put_mapping( &self, k: EthHash, v: Cid, timestamp: u64, ) -> Result<(), Error>

Writes with timestamp the Hash to Cid mapping to the blockstore for EthAPI queries.

pub fn get_mapping(&self, hash: &EthHash) -> Result<Option<Cid>, Error>

Reads the Cid from the blockstore for EthAPI queries.

fn expand_tipset(&self, header: CachingBlockHeader) -> Result<Tipset, Error>

Expands tipset to tipset with all other headers in the same epoch using the tipset tracker.

pub fn genesis_block_header(&self) -> &CachingBlockHeader

pub fn heaviest_tipset(&self) -> Arc<Tipset>

Returns the currently tracked heaviest tipset.

pub fn publisher(&self) -> &Publisher<HeadChange>

Returns a reference to the publisher of head changes.

pub fn blockstore(&self) -> &DB

Returns key-value store instance.

pub fn load_required_tipset_or_heaviest<'a>( &self, maybe_key: impl Into<Option<&'a TipsetKey>>, ) -> Result<Arc<Tipset>, Error>

Lotus often treats an empty TipsetKey as shorthand for “the heaviest tipset”. You may opt-in to that behavior by calling this method with None.

This calls fails if the tipset is missing or invalid.

fn update_heaviest(&self, ts: Arc<Tipset>) -> Result<(), Error>

Determines if provided tipset is heavier than existing known heaviest tipset

pub fn is_block_validated(&self, cid: &Cid) -> bool

Checks metadata file if block has already been validated.

pub fn mark_block_as_validated(&self, cid: &Cid)

Marks block as validated in the metadata file.

pub fn unmark_block_as_validated(&self, cid: &Cid)

pub fn messages_for_tipset( &self, ts: &Tipset, ) -> Result<Vec<ChainMessage>, Error>

Retrieves ordered valid messages from a Tipset. This will only include messages that will be passed through the VM.

pub fn get_lookback_tipset_for_round( chain_index: Arc<ChainIndex<Arc<DB>>>, chain_config: Arc<ChainConfig>, heaviest_tipset: Arc<Tipset>, round: i64, ) -> Result<(Arc<Tipset>, Cid), Error>

where DB: Send + Sync + 'static,

Gets look-back tipset (and state-root of that tipset) for block validations.

The look-back tipset for a round is the tipset with epoch round - chain_finality. Chain finality is usually 900. The heaviest_tipset is a reference point in the blockchain. It must be a child of the look-back tipset.

pub fn settings(&self) -> Arc<dyn SettingsStore + Sync + Send>

pub fn process_signed_messages( &self, messages: &[(SignedMessage, u64)], ) -> Result<()>

where DB: Blockstore,

Filter SignedMessage’s to keep only the most recent ones, then write corresponding entries to the Ethereum mapping.

pub fn headers_delegated_messages<'a>( &self, headers: impl Iterator<Item = &'a CachingBlockHeader>, ) -> Result<Vec<(SignedMessage, u64)>>

where DB: Blockstore,

Trait Implementations

impl<DB> BitswapStoreRead for ChainStore<DB>

where DB: BitswapStoreRead,

fn contains(&self, cid: &Cid) -> Result<bool>

A have query needs to know if the block store contains the block.

fn get(&self, cid: &Cid) -> Result<Option<Vec<u8>>>

A block query needs to retrieve the block from the store.

impl<DB> BitswapStoreReadWrite for ChainStore<DB>

where DB: BitswapStoreReadWrite,

type Params = <DB as BitswapStoreReadWrite>::Params

The store parameters.

fn insert(&self, block: &Block<Self::Params>) -> Result<()>

A block response needs to insert the block into the store.