Struct cfxcore::consensus::consensus_inner::consensus_executor::ConsensusExecutor

pub struct ConsensusExecutor {
    pub handler: Arc<ConsensusExecutionHandler>,
    /* private fields */
}

ConsensusExecutor processes transaction execution tasks.

Fields

handler: Arc<ConsensusExecutionHandler>

The handler to provide functions to handle ExecutionTask and execute transactions It is used both asynchronously by self.thread and synchronously by the executor itself

Implementations

impl ConsensusExecutor

pub fn start( tx_pool: SharedTransactionPool, data_man: Arc<BlockDataManager>, consensus_inner: Arc<RwLock<ConsensusGraphInner>>, config: ConsensusExecutionConfiguration, verification_config: VerificationConfig, bench_mode: bool, pos_verifier: Arc<PosVerifier> ) -> Arc<Self>

pub fn wait_for_result( &self, epoch_hash: H256 ) -> Result<EpochExecutionCommitment, String>

Wait until all tasks currently in the queue to be executed and return (state_root, receipts_root, logs_bloom_hash) of the given epoch_hash.

It is the caller’s responsibility to ensure that epoch_hash is indeed computed when all the tasks before are finished.

pub fn get_reward_execution_info_from_index( &self, inner: &mut ConsensusGraphInner, reward_index: Option<(usize, usize)> ) -> Option<RewardExecutionInfo>

pub fn get_reward_execution_info( &self, inner: &mut ConsensusGraphInner, epoch_arena_index: usize ) -> Option<RewardExecutionInfo>

pub fn get_blame_and_deferred_state_for_generation( &self, parent_block_hash: &H256, inner_lock: &RwLock<ConsensusGraphInner> ) -> Result<StateBlameInfo, String>

pub fn enqueue_epoch(&self, task: EpochExecutionTask) -> bool

Enqueue the epoch to be executed by the background execution thread The parameters are needed for the thread to execute this epoch without holding inner lock.

pub fn compute_epoch( &self, task: EpochExecutionTask, debug_record: Option<&mut ComputeEpochDebugRecord>, recover_mpt_during_construct_pivot_state: bool )

Execute the epoch synchronously

pub fn epoch_executed_and_recovered( &self, epoch_hash: &H256, epoch_block_hashes: &Vec<H256>, on_local_pivot: bool, reward_execution_info: &Option<RewardExecutionInfo>, epoch_height: u64 ) -> bool

pub fn call_virtual( &self, tx: &SignedTransaction, epoch_id: &H256, epoch_size: usize, request: EstimateRequest, evm_overrides: EvmOverrides ) -> CoreResult<(ExecutionOutcome, EstimateExt)>

pub fn collect_blocks_geth_trace( &self, epoch_id: H256, epoch_num: u64, blocks: &Vec<Arc<Block>>, opts: GethDebugTracingOptions, tx_hash: Option<H256> ) -> CoreResult<Vec<GethTraceWithHash>>

pub fn stop(&self)

pub fn compute_state_for_block( &self, block_hash: &H256, inner: &mut ConsensusGraphInner ) -> Result<(), String>

This is a blocking call to force the execution engine to compute the state of a block immediately