Struct casper_execution_engine::core::engine_state::EngineState

pub struct EngineState<S> { /* private fields */ }

Main implementation of an execution engine state.

Takes an engine’s configuration and a provider of a state (aka the global state) to operate on. Methods implemented on this structure are the external API intended to be used by the users such as the node, test framework, and others.

Implementations

impl EngineState<ScratchGlobalState>

pub fn into_inner(self) -> ScratchGlobalState

Returns the inner state

impl EngineState<LmdbGlobalState>

pub fn get_state(&self) -> &LmdbGlobalState

Gets underlyng LmdbGlobalState

pub fn flush_environment(&self) -> Result<(), Error>

Flushes the LMDB environment to disk when manual sync is enabled in the config.toml.

pub fn get_scratch_engine_state(&self) -> EngineState<ScratchGlobalState>

Provide a local cached-only version of engine-state.

pub fn write_scratch_to_db( &self, state_root_hash: Digest, scratch_global_state: ScratchGlobalState ) -> Result<Digest, Error>

Writes state cached in an EngineState<ScratchEngineState> to LMDB.

impl<S> EngineState<S>where S: StateProvider + CommitProvider, S::Error: Into<Error>,

pub fn new(state: S, config: EngineConfig) -> EngineState<S>

Creates new engine state.

pub fn config(&self) -> &EngineConfig

Returns engine config.

pub fn update_config(&mut self, new_config: EngineConfig)

Updates current engine config with a new instance.

pub fn commit_genesis( &self, correlation_id: CorrelationId, genesis_config_hash: Digest, protocol_version: ProtocolVersion, ee_config: &ExecConfig, chainspec_registry: ChainspecRegistry ) -> Result<GenesisSuccess, Error>

Commits genesis process.

This process is run only once per network to initiate the system. By definition users are unable to execute smart contracts on a network without a genesis.

Takes genesis configuration passed through ExecConfig and creates the system contracts, sets up the genesis accounts, and sets up the auction state based on that. At the end of the process, SystemContractRegistry is persisted under the special global state space Key::SystemContractRegistry.

Returns a GenesisSuccess for a successful operation, or an error otherwise.

pub fn commit_upgrade( &self, correlation_id: CorrelationId, upgrade_config: UpgradeConfig ) -> Result<UpgradeSuccess, Error>

Commits upgrade.

This process applies changes to the global state.

Returns UpgradeSuccess.

pub fn commit_prune( &self, correlation_id: CorrelationId, prune_config: PruneConfig ) -> Result<PruneResult, Error>

Commit a prune of leaf nodes from the tip of the merkle trie.

pub fn tracking_copy( &self, hash: Digest ) -> Result<Option<TrackingCopy<S::Reader>>, Error>

Creates a new tracking copy instance.

pub fn run_query( &self, correlation_id: CorrelationId, query_request: QueryRequest ) -> Result<QueryResult, Error>

Executes a query.

For a given root Key it does a path lookup through the named keys.

Returns the value stored under a URef wrapped in a QueryResult.

pub fn run_execute( &self, correlation_id: CorrelationId, exec_request: ExecuteRequest ) -> Result<ExecutionResults, Error>

Runs a deploy execution request.

For each deploy stored in the request it will execute it.

Currently a special shortcut is taken to distinguish a native transfer, from a deploy.

Return execution results which contains results from each deploy ran.

pub fn get_purse_balance( &self, correlation_id: CorrelationId, state_hash: Digest, purse_uref: URef ) -> Result<BalanceResult, Error>

Get the balance of a passed purse referenced by its URef.

pub fn transfer( &self, correlation_id: CorrelationId, executor: &Executor, protocol_version: ProtocolVersion, prestate_hash: Digest, blocktime: BlockTime, deploy_item: DeployItem, proposer: PublicKey ) -> Result<ExecutionResult, Error>

Executes a native transfer.

Native transfers do not involve WASM at all, and also skip executing payment code. Therefore this is the fastest and cheapest way to transfer tokens from account to account.

Returns an ExecutionResult for a successful native transfer.

pub fn deploy( &self, correlation_id: CorrelationId, executor: &Executor, protocol_version: ProtocolVersion, prestate_hash: Digest, blocktime: BlockTime, deploy_item: DeployItem, proposer: PublicKey ) -> Result<ExecutionResult, Error>

Executes a deploy.

A deploy execution consists of running the payment code, which is expected to deposit funds into the payment purse, and then running the session code with a specific gas limit. For running payment code, we lock MAX_PAYMENT amount of motes from the user as collateral. If both the payment code and the session code execute successfully, a fraction of the unspent collateral will be transferred back to the proposer of the deploy, as specified in the request.

Returns ExecutionResult, or an error condition.

pub fn apply_effect( &self, correlation_id: CorrelationId, pre_state_hash: Digest, effects: AdditiveMap<Key, Transform> ) -> Result<Digest, Error>

Apply effects of the execution.

This is also referred to as “committing” the effects into the global state. This method has to be run after an execution has been made to persists the effects of it.

Returns new state root hash.

pub fn get_trie_full( &self, correlation_id: CorrelationId, trie_key: Digest ) -> Result<Option<TrieRaw>, Error>where Error: From<S::Error>,

Gets a trie object for given state root hash.

pub fn put_trie_if_all_children_present( &self, correlation_id: CorrelationId, trie_bytes: &[u8] ) -> Result<Digest, Error>where Error: From<S::Error>,

Puts a trie if no children are missing from the global state; otherwise reports the missing children hashes via the Error enum.

pub fn get_era_validators( &self, correlation_id: CorrelationId, system_contract_registry: Option<SystemContractRegistry>, get_era_validators_request: GetEraValidatorsRequest ) -> Result<EraValidators, GetEraValidatorsError>

Obtains validator weights for given era.

This skips execution of auction’s get_era_validator entry point logic to avoid creating an executor instance, and going through the execution flow. It follows the same process but uses queries rather than execution to get the snapshot.

pub fn get_bids( &self, correlation_id: CorrelationId, get_bids_request: GetBidsRequest ) -> Result<GetBidsResult, Error>

Gets current bids from the auction system.

pub fn commit_step( &self, correlation_id: CorrelationId, step_request: StepRequest ) -> Result<StepSuccess, StepError>

Executes a step request.

pub fn get_balance( &self, correlation_id: CorrelationId, state_hash: Digest, public_key: PublicKey ) -> Result<BalanceResult, Error>

Gets the balance of a given public key.

pub fn get_system_contract_registry( &self, correlation_id: CorrelationId, state_root_hash: Digest ) -> Result<SystemContractRegistry, Error>

Obtains an instance of a system contract registry for a given state root hash.

pub fn get_system_mint_hash( &self, correlation_id: CorrelationId, state_hash: Digest ) -> Result<ContractHash, Error>

Returns mint system contract hash.

pub fn get_system_auction_hash( &self, correlation_id: CorrelationId, state_hash: Digest ) -> Result<ContractHash, Error>

Returns auction system contract hash.

pub fn get_handle_payment_hash( &self, correlation_id: CorrelationId, state_hash: Digest ) -> Result<ContractHash, Error>

Returns handle payment system contract hash.

pub fn get_standard_payment_hash( &self, correlation_id: CorrelationId, state_hash: Digest ) -> Result<ContractHash, Error>

Returns standard payment system contract hash.

pub fn get_checksum_registry( &self, correlation_id: CorrelationId, state_root_hash: Digest ) -> Result<Option<ChecksumRegistry>, Error>

Returns the checksum registry at the given state root hash.

pub fn get_checksum_registry_proof( &self, correlation_id: CorrelationId, state_root_hash: Digest ) -> Result<TrieMerkleProof<Key, StoredValue>, Error>

Returns the Merkle proof for the checksum registry at the given state root hash.

Trait Implementations

impl<S: Debug> Debug for EngineState<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.