Struct massa_execution_worker::execution::ExecutionState

pub(crate) struct ExecutionState {

    config: ExecutionConfig,
    pub active_history: Arc<RwLock<ActiveHistory>>,
    pub active_cursor: Slot,
    pub final_cursor: Slot,
    final_events_cache: Box<dyn EventCacheController>,
    final_state: Arc<RwLock<dyn FinalStateController>>,
    execution_context: Arc<Mutex<ExecutionContext>>,
    execution_interface: Box<dyn Interface>,
    stats_counter: ExecutionStatsCounter,
    pub module_cache: Arc<RwLock<ModuleCache>>,
    mip_store: MipStore,
    wallet: Arc<RwLock<Wallet>>,
    selector: Box<dyn SelectorController>,
    channels: ExecutionChannels,
    massa_metrics: MassaMetrics,
}

Structure holding consistent speculative and final execution states, and allowing access to them.

Fields

config: ExecutionConfig

active_history: Arc<RwLock<ActiveHistory>>

active_cursor: Slot

final_cursor: Slot

final_events_cache: Box<dyn EventCacheController>

final_state: Arc<RwLock<dyn FinalStateController>>

execution_context: Arc<Mutex<ExecutionContext>>

execution_interface: Box<dyn Interface>

stats_counter: ExecutionStatsCounter

module_cache: Arc<RwLock<ModuleCache>>

mip_store: MipStore

wallet: Arc<RwLock<Wallet>>

selector: Box<dyn SelectorController>

channels: ExecutionChannels

massa_metrics: MassaMetrics

prometheus metrics

Implementations

impl ExecutionState

pub fn new( config: ExecutionConfig, final_state: Arc<RwLock<dyn FinalStateController>>, mip_store: MipStore, selector: Box<dyn SelectorController>, channels: ExecutionChannels, wallet: Arc<RwLock<Wallet>>, massa_metrics: MassaMetrics, event_cache: Box<dyn EventCacheController>, ) -> ExecutionState

Create a new execution state. This should be called only once at the start of the execution worker.

Arguments

• config: execution configuration
• final_state: atomic access to the final state

returns

A new ExecutionState

pub fn get_final_state_fingerprint(&self) -> Hash

Get the fingerprint of the final state

pub fn get_stats(&self) -> ExecutionStats

Get execution statistics

pub fn apply_final_execution_output(&mut self, exec_out: ExecutionOutput)

Applies the output of an execution to the final execution state. The newly applied final output should be from the slot just after the last executed final slot

Arguments

• exec_out: execution output to apply

pub fn apply_active_execution_output(&mut self, exec_out: ExecutionOutput)

Applies an execution output to the active (non-final) state The newly active final output should be from the slot just after the last executed active slot

Arguments

• exec_out: execution output to apply

fn prepare_operation_for_execution( &self, operation: &SecureShareOperation, sender_addr: Address, ) -> Result<ExecutionContextSnapshot, ExecutionError>

Helper function. Within a locked execution context (lock is taken at the beginning of the function then released at the end):

• if not yet executed then transfer fee and add the operation to the context then return a context snapshot

Arguments

• operation: operation to be schedule
• sender_addr: sender address for the operation (for fee transfer)

pub fn execute_operation( &self, operation: &SecureShareOperation, block_slot: Slot, remaining_block_gas: &mut u64, block_credits: &mut Amount, ) -> Result<(), ExecutionError>

Execute an operation in the context of a block. Assumes the execution context was initialized at the beginning of the slot.

Arguments

• operation: operation to execute
• block_slot: slot of the block in which the op is included
• remaining_block_gas: mutable reference towards the remaining gas in the block
• block_credits: mutable reference towards the total block reward/fee credits

fn execute_denunciation( &self, denunciation: &Denunciation, block_slot: &Slot, block_credits: &mut Amount, ) -> Result<DenunciationResult, ExecutionError>

Execute a denunciation in the context of a block.

Arguments

• denunciation: denunciation to process
• block_credits: mutable reference towards the total block reward/fee credits

pub fn execute_roll_sell_op( &self, operation: &OperationType, seller_addr: Address, operation_id: OperationId, ) -> Result<(), ExecutionError>

Execute an operation of type RollSell Will panic if called with another operation type

Arguments

• operation: the WrappedOperation to process, must be an RollSell
• sender_addr: address of the sender

pub fn execute_roll_buy_op( &self, operation: &OperationType, buyer_addr: Address, operation_id: OperationId, ) -> Result<(), ExecutionError>

Execute an operation of type RollBuy Will panic if called with another operation type

Arguments

• operation: the WrappedOperation to process, must be an RollBuy
• buyer_addr: address of the buyer

pub fn execute_transaction_op( &self, operation: &OperationType, sender_addr: Address, operation_id: OperationId, ) -> Result<(), ExecutionError>

Execute an operation of type Transaction Will panic if called with another operation type

Arguments

• operation: the WrappedOperation to process, must be a Transaction
• operation_id: ID of the operation
• sender_addr: address of the sender

pub fn execute_executesc_op( &self, operation: &OperationType, sender_addr: Address, ) -> Result<(), ExecutionError>

Execute an operation of type ExecuteSC Will panic if called with another operation type

Arguments

• operation: the WrappedOperation to process, must be an ExecuteSC
• sender_addr: address of the sender

pub fn execute_callsc_op( &self, operation: &OperationType, sender_addr: Address, operation_id: OperationId, ) -> Result<(), ExecutionError>

Execute an operation of type CallSC Will panic if called with another operation type

Arguments

• operation: the WrappedOperation to process, must be an CallSC
• block_creator_addr: address of the block creator
• operation_id: ID of the operation
• sender_addr: address of the sender

pub fn execute_async_message( &self, message: AsyncMessage, bytecode: Option<Bytecode>, ) -> Result<AsyncMessageExecutionResult, ExecutionError>

Tries to execute an asynchronous message If the execution failed reimburse the message sender.

Arguments

• message: message information
• bytecode: executable target bytecode, or None if unavailable

fn execute_deferred_call( &self, id: &DeferredCallId, call: DeferredCall, ) -> Result<DeferredCallExecutionResult, ExecutionError>

pub fn execute_slot( &mut self, slot: &Slot, exec_target: Option<&(BlockId, ExecutionBlockMetadata)>, selector: Box<dyn SelectorController>, ) -> ExecutionOutput

Executes a full slot (with or without a block inside) without causing any changes to the state, just yielding the execution output.

Arguments

• slot: slot to execute
• exec_target: metadata of the block to execute, if not miss
• selector: Reference to the selector

Returns

An ExecutionOutput structure summarizing the output of the executed slot

pub fn execute_candidate_slot( &mut self, slot: &Slot, exec_target: Option<&(BlockId, ExecutionBlockMetadata)>, selector: Box<dyn SelectorController>, )

Execute a candidate slot

pub fn execute_final_slot( &mut self, slot: &Slot, exec_target: Option<&(BlockId, ExecutionBlockMetadata)>, selector: Box<dyn SelectorController>, )

Execute an SCE-final slot

pub(crate) fn execute_readonly_request( &self, req: ReadOnlyExecutionRequest, ) -> Result<ReadOnlyExecutionOutput, ExecutionError>

Runs a read-only execution request. The executed bytecode appears to be able to read and write the consensus state, but all accumulated changes are simply returned as an ExecutionOutput object, and not actually applied to the consensus state.

Arguments

• req: a read-only execution request

Returns

ExecutionOutput describing the output of the execution, or an error

pub fn get_final_and_candidate_balance( &self, address: &Address, ) -> (Option<Amount>, Option<Amount>)

Gets a balance both at the latest final and candidate executed slots

pub fn get_final_and_active_bytecode( &self, address: &Address, ) -> (Option<Bytecode>, Option<Bytecode>)

Gets a balance both at the latest final and candidate executed slots

pub fn get_final_and_candidate_rolls(&self, address: &Address) -> (u64, u64)

Gets roll counts both at the latest final and active executed slots

pub fn get_final_and_active_data_entry( &self, address: &Address, key: &[u8], ) -> (Option<Vec<u8>>, Option<Vec<u8>>)

Gets a data entry both at the latest final and active executed slots

pub fn get_final_datastore_keys( &self, addr: &Address, prefix: &[u8], start_key: Bound<Vec<u8>>, end_key: Bound<Vec<u8>>, count: Option<u32>, ) -> Option<BTreeSet<Vec<u8>>>

pub fn get_final_and_candidate_datastore_keys( &self, addr: &Address, prefix: &[u8], start_key: Bound<Vec<u8>>, end_key: Bound<Vec<u8>>, count: Option<u32>, ) -> (Option<BTreeSet<Vec<u8>>>, Option<BTreeSet<Vec<u8>>>)

Get every final and active datastore key of the given address

pub fn get_address_cycle_infos( &self, address: &Address, ) -> Vec<ExecutionAddressCycleInfo>

pub fn get_cycle_active_rolls(&self, cycle: u64) -> BTreeMap<Address, u64>

Returns for a given cycle the stakers taken into account by the selector. That correspond to the roll_counts in cycle - 3.

By default it returns an empty map.

pub fn get_filtered_sc_output_event( &self, filter: EventFilter, ) -> Vec<SCOutputEvent>

Gets execution events optionally filtered by:

• start slot
• end slot
• emitter address
• original caller address
• operation id
• event state (final, candidate or both)

pub fn get_denunciation_execution_status( &self, denunciation_index: &DenunciationIndex, ) -> (bool, bool)

Check if a denunciation has been executed given a DenunciationIndex Returns a tuple of booleans:

• first boolean is true if the denunciation has been executed speculatively
• second boolean is true if the denunciation has been executed in the final state

pub fn get_cycle_infos( &self, cycle: u64, restrict_to_addresses: Option<&PreHashSet<Address>>, ) -> Option<ExecutionQueryCycleInfos>

Get cycle infos

pub fn get_address_future_deferred_credits( &self, address: &Address, max_slot: Bound<Slot>, ) -> BTreeMap<Slot, Amount>

Get future deferred credits of an address

pub fn get_address_deferred_credits( &self, address: &Address, ) -> (BTreeMap<Slot, Amount>, BTreeMap<Slot, Amount>)

Get future deferred credits of an address Returns tuple: (speculative, final)

pub fn get_ops_exec_status( &self, batch: &[OperationId], ) -> Vec<(Option<bool>, Option<bool>)>

Get the execution status of a batch of operations.

Return value: vector of (Option<speculative_status>, Option<final_status>) If an Option is None it means that the op execution was not found. Note that old op executions are forgotten. Otherwise, the status is a boolean indicating whether the execution was successful (true) or if there was an error (false.)

pub fn update_versioning_stats( &mut self, block_info: &Option<ExecutedBlockInfo>, slot: &Slot, )

Update MipStore with block header stats

pub fn deferred_call_quote( &self, target_slot: Slot, max_request_gas: u64, params_size: u64, ) -> (Slot, u64, bool, Amount)

pub fn deferred_call_info( &self, call_id: &DeferredCallId, ) -> Option<DeferredCall>

pub fn get_deferred_calls_by_slot(&self, slot: Slot) -> Vec<DeferredCallId>