Struct cfxcore::block_data_manager::BlockDataManager

pub struct BlockDataManager {
    pub db_manager: DBManager,
    pub pow: Arc<PowComputer>,
    pub true_genesis: Arc<Block>,
    pub storage_manager: Arc<StorageManager>,
    pub target_difficulty_manager: TargetDifficultyManager,
    pub state_availability_boundary: RwLock<StateAvailabilityBoundary>,
    /* private fields */
}

Fields

db_manager: DBManager

pow: Arc<PowComputer>

true_genesis: Arc<Block>

This is the original genesis block.

storage_manager: Arc<StorageManager>

target_difficulty_manager: TargetDifficultyManager

state_availability_boundary: RwLock<StateAvailabilityBoundary>

This maintains the boundary height of available state and commitments (executed but not deleted or in ExecutionTaskQueue). The upper bound always equal to latest executed epoch height. As for the lower bound:

1. For archive node, it always equals cur_era_stable_height.
2. For full node, it equals the height of remotely synchronized state at start, and equals cur_era_stable_height after making a new checkpoint.

The lower boundary height will be updated when:

1. New checkpoint
2. Full Node snapshot syncing
3. New Snapshot

The upper boundary height will be updated when:

1. Pivot chain switch
2. Execution of new epoch

The state of an epoch is valid if and only if the height of the epoch is inside the boundary.

Implementations

impl BlockDataManager

pub fn new( cache_conf: CacheConfig, true_genesis: Arc<Block>, db: Arc<SystemDB>, storage_manager: Arc<StorageManager>, worker_pool: Arc<Mutex<ThreadPool>>, config: DataManagerConfiguration, pow: Arc<PowComputer> ) -> Self

pub fn get_instance_id(&self) -> u64

pub fn initialize_instance_id(&self)

pub fn true_genesis_state_root(&self) -> StateRootWithAuxInfo

This will return the state root of true genesis block.

pub fn transaction_by_hash(&self, hash: &H256) -> Option<Arc<SignedTransaction>>

pub fn insert_block_body(&self, hash: H256, block: Arc<Block>, persistent: bool)

insert block body in memory cache and db

pub fn remove_block_body(&self, hash: &H256, remove_db: bool)

remove block body in memory cache and db

pub fn block_by_hash( &self, hash: &H256, update_cache: bool ) -> Option<Arc<Block>>

TODO Also set block header

pub fn block_from_db(&self, hash: &H256) -> Option<Block>

This function returns the block from db without wrapping it in Arc.

pub fn blocks_by_hash_list( &self, hashes: &Vec<H256>, update_cache: bool ) -> Option<Vec<Arc<Block>>>

pub fn insert_block(&self, block: Arc<Block>, persistent: bool)

insert block/header into memory cache, block/header into db

pub fn remove_useless_block(&self, hash: &H256, remove_db: bool)

Remove block body and block header in memory cache and db. This is used to delete invalid blocks or dangling blocks never connected to the pivot chain.

pub fn block_traces_by_hash(&self, hash: &H256) -> Option<BlockTracesWithEpoch>

Get the traces for a single block without checking the assumed pivot block

pub fn transactions_traces_by_block_hash( &self, hash: &H256 ) -> Option<(H256, Vec<TransactionExecTraces>)>

Return (pivot_hash, tx_traces).

pub fn block_traces_by_hash_with_epoch( &self, hash: &H256, assumed_epoch: &H256, update_pivot_assumption: bool, update_cache: bool ) -> Option<BlockExecTraces>

pub fn insert_block_traces( &self, hash: H256, trace: BlockExecTraces, pivot_hash: H256, persistent: bool )

pub fn remove_block_traces(&self, hash: &H256, remove_db: bool)

remove block traces in memory cache and db

pub fn block_header_by_hash(&self, hash: &H256) -> Option<Arc<BlockHeader>>

pub fn insert_block_header( &self, hash: H256, header: Arc<BlockHeader>, persistent: bool )

pub fn remove_block_header(&self, hash: &H256, remove_db: bool)

remove block header in memory cache and db

pub fn block_height_by_hash(&self, hash: &H256) -> Option<u64>

pub fn pos_reference_by_hash(&self, hash: &H256) -> Option<Option<PosBlockId>>

Return None if the header does not exist. Return Some(None) if the header exist but it does not have a PoS reference field.

pub fn compact_block_by_hash(&self, hash: &H256) -> Option<CompactBlock>

pub fn insert_compact_block(&self, cb: CompactBlock)

pub fn contains_compact_block(&self, hash: &H256) -> bool

pub fn block_execution_result_by_hash_with_epoch( &self, hash: &H256, assumed_epoch: &H256, update_pivot_assumption: bool, update_cache: bool ) -> Option<BlockExecutionResult>

Return None if receipts for corresponding epoch is not computed before or has been overwritten by another new pivot chain in db. If update_pivot_assumption is true and we have execution results of assumed_epoch in memory, we will also ensure assumed_epoch is persisted as the pivot hash in db.

This function will require lock of block_receipts.

pub fn block_execution_result_by_hash_from_db( &self, hash: &H256 ) -> Option<BlockExecutionResultWithEpoch>

pub fn block_epoch_number(&self, hash: &H256) -> Option<u64>

pub fn insert_block_execution_result( &self, hash: H256, epoch: H256, block_receipts: Arc<BlockReceipts>, persistent: bool )

pub fn insert_block_reward_result( &self, hash: H256, epoch: &H256, block_reward: BlockRewardResult, persistent: bool )

pub fn block_reward_result_by_hash_with_epoch( &self, hash: &H256, assumed_epoch_later: &H256, update_pivot_assumption: bool, update_cache: bool ) -> Option<BlockRewardResult>

pub fn remove_block_result(&self, hash: &H256, remove_db: bool)

pub fn transaction_index_by_hash( &self, hash: &H256, update_cache: bool ) -> Option<TransactionIndex>

pub fn insert_transaction_index(&self, hash: &H256, tx_index: &TransactionIndex)

pub fn hash_by_block_number( &self, block_number: u64, update_cache: bool ) -> Option<H256>

pub fn insert_hash_by_block_number(&self, block_number: u64, block_hash: &H256)

pub fn insert_local_block_info(&self, hash: &H256, info: LocalBlockInfo)

pub fn local_block_info_by_hash(&self, hash: &H256) -> Option<LocalBlockInfo>

pub fn insert_blamed_header_verified_roots( &self, height: u64, roots: BlamedHeaderVerifiedRoots )

pub fn verified_blamed_roots_by_height( &self, height: u64 ) -> Option<BlamedHeaderVerifiedRoots>

Get correct roots of blamed headers from db. These are maintained on light nodes only.

pub fn remove_blamed_header_verified_roots(&self, height: u64)

pub fn insert_terminals_to_db(&self, terminals: Vec<H256>)

pub fn terminals_from_db(&self) -> Option<Vec<H256>>

pub fn insert_executed_epoch_set_hashes_to_db( &self, epoch_number: u64, epoch_set: &Vec<H256> )

pub fn insert_skipped_epoch_set_hashes_to_db( &self, epoch_number: u64, skipped_set: &Vec<H256> )

pub fn executed_epoch_set_hashes_from_db( &self, epoch_number: u64 ) -> Option<Vec<H256>>

pub fn skipped_epoch_set_hashes_from_db( &self, epoch_number: u64 ) -> Option<Vec<H256>>

pub fn all_epoch_set_hashes_from_db( &self, epoch_number: u64 ) -> Option<Vec<H256>>

pub fn receipts_retain_epoch(&self, block_hash: &H256, epoch: &H256) -> bool

Return false if there is no executed results for given block_hash

pub fn insert_epoch_execution_context( &self, hash: H256, ctx: EpochExecutionContext, persistent: bool )

pub fn get_epoch_execution_context( &self, hash: &H256 ) -> Option<EpochExecutionContext>

The in-memory state will not be updated because it’s only garbage collected explicitly when we make checkpoints.

pub fn insert_epoch_execution_commitment( &self, block_hash: H256, state_root_with_aux_info: StateRootWithAuxInfo, receipts_root: H256, logs_bloom_hash: H256 )

TODO We can avoid persisting execution_commitments for blocks not on the pivot chain after a checkpoint

pub fn get_epoch_execution_commitment( &self, block_hash: &H256 ) -> GuardedValue<RwLockReadGuard<'_, HashMap<H256, EpochExecutionCommitment>>, NonCopy<Option<&EpochExecutionCommitment>>>

Get in-mem execution commitment.

pub fn load_epoch_execution_commitment_from_db( &self, block_hash: &H256 ) -> Option<EpochExecutionCommitment>

Load commitment from db. The caller should ensure that the loaded commitment is after cur_era_genesis and can be garbage-collected by checkpoint.

pub fn get_epoch_execution_commitment_with_db( &self, block_hash: &H256 ) -> Option<EpochExecutionCommitment>

Get persisted execution commitment. It will check db if it’s missing in db.

pub fn insert_pos_reward(&self, pos_epoch: u64, pos_reward: &PosRewardInfo)

pub fn pos_reward_by_pos_epoch(&self, pos_epoch: u64) -> Option<PosRewardInfo>

pub fn remove_epoch_execution_commitment(&self, block_hash: &H256)

pub fn remove_epoch_execution_commitment_from_db(&self, block_hash: &H256)

pub fn remove_epoch_execution_context(&self, block_hash: &H256)

pub fn remove_epoch_execution_context_from_db(&self, block_hash: &H256)

pub fn epoch_executed(&self, epoch_hash: &H256) -> bool

pub fn epoch_executed_and_recovered( &self, epoch_hash: &H256, epoch_block_hashes: &Vec<H256>, on_local_pivot: bool, update_trace: bool, reward_execution_info: &Option<RewardExecutionInfo>, pos_verifier: &PosVerifier, evm_chain_id: u32 ) -> bool

Check if all executed results of an epoch exist

pub fn invalidate_block(&self, block_hash: H256)

pub fn verified_invalid( &self, block_hash: &H256 ) -> (bool, Option<LocalBlockInfo>)

Check if a block is already marked as invalid.

pub fn cached_block_count(&self) -> usize

pub fn cache_size(&self) -> CacheSize

Get current cache size.

pub fn cache_gc(&self)

pub fn set_cur_consensus_era_genesis_hash( &self, cur_era_hash: &H256, next_era_hash: &H256 )

pub fn get_cur_consensus_era_genesis_hash(&self) -> H256

pub fn get_cur_consensus_era_stable_hash(&self) -> H256

pub fn recover_unsigned_tx( &self, transactions: &Vec<TransactionWithSignature> ) -> Result<Vec<Arc<SignedTransaction>>, DecoderError>

pub fn recover_block(&self, block: &mut Block) -> Result<(), DecoderError>

pub fn recover_unsigned_tx_with_order( &self, transactions: &Vec<TransactionWithSignature> ) -> Result<Vec<Arc<SignedTransaction>>, DecoderError>

pub fn find_missing_tx_indices_encoded( &self, compact_block: &mut CompactBlock ) -> Vec<usize>

pub fn get_state_readonly_index( &self, block_hash: &EpochId ) -> Option<StateIndex>

Caller should make sure the state exists.

pub fn get_parent_epochs_for( &self, block: EpochId, count: u64 ) -> (EpochId, Vec<EpochId>)

pub fn get_snapshot_epoch_count(&self) -> u32

pub fn get_snapshot_blame_plus_depth(&self) -> usize

pub fn get_executed_state_root(&self, block_hash: &H256) -> Option<H256>

pub fn earliest_epoch_with_block_body(&self) -> u64

pub fn earliest_epoch_with_execution_result(&self) -> u64

pub fn earliest_epoch_with_trace(&self) -> u64

pub fn new_checkpoint(&self, new_checkpoint_height: u64, best_epoch_number: u64)

pub fn database_gc(&self, best_epoch: u64)

Trait Implementations

impl MallocSizeOf for BlockDataManager

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.