Struct casper_execution_engine::core::runtime::Runtime

pub struct Runtime<'a, R> { /* fields omitted */ }

Implementations

impl<'a, R> Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

pub fn new(
    config: EngineConfig,
    system_contract_cache: SystemContractCache,
    memory: MemoryRef,
    module: Module,
    context: RuntimeContext<'a, R>,
    call_stack: Vec<CallStackElement>
) -> Self

pub fn memory(&self) -> &MemoryRef

pub fn module(&self) -> &Module

pub fn context(&self) -> &RuntimeContext<'a, R>

pub fn protocol_data(&self) -> &ProtocolData

pub fn call_stack(&self) -> &Vec<CallStackElement>

pub fn is_mint(&self, key: Key) -> bool

pub fn is_handle_payment(&self, key: Key) -> bool

pub fn is_auction(&self, key: Key) -> bool

pub fn call_host_mint(
    &mut self,
    protocol_version: ProtocolVersion,
    entry_point_name: &str,
    named_keys: &mut NamedKeys,
    runtime_args: &RuntimeArgs,
    extra_keys: &[Key],
    call_stack: Vec<CallStackElement>
) -> Result<CLValue, Error>

pub fn call_host_handle_payment(
    &mut self,
    protocol_version: ProtocolVersion,
    entry_point_name: &str,
    named_keys: &mut NamedKeys,
    runtime_args: &RuntimeArgs,
    extra_keys: &[Key],
    call_stack: Vec<CallStackElement>
) -> Result<CLValue, Error>

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

pub fn call_host_auction(
    &mut self,
    protocol_version: ProtocolVersion,
    entry_point_name: &str,
    named_keys: &mut NamedKeys,
    runtime_args: &RuntimeArgs,
    extra_keys: &[Key],
    call_stack: Vec<CallStackElement>
) -> Result<CLValue, Error>

pub fn call_contract(
    &mut self,
    contract_hash: ContractHash,
    entry_point_name: &str,
    args: RuntimeArgs
) -> Result<CLValue, Error>

Calls contract living under a key, with supplied args.

pub fn call_versioned_contract(
    &mut self,
    contract_package_hash: ContractPackageHash,
    contract_version: Option<ContractVersion>,
    entry_point_name: String,
    args: RuntimeArgs
) -> Result<CLValue, Error>

Calls version of the contract living at key, invoking method with supplied args. This function also checks the args conform with the types given in the contract header.

pub fn take_host_buffer(&mut self) -> Option<CLValue>

If host_buffer set, clears the host_buffer and returns value, else None

Trait Implementations

impl<'a, R> AccountProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_main_purse(&self) -> Result<URef, Error>

Get currently executing account’s purse.

impl<'a, R> AccountProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_main_purse(&self) -> Result<URef, ApiError>

Get currently executing account’s purse.

impl<'a, R> Auction for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_era_validators(
    &mut self
) -> Result<BTreeMap<EraId, BTreeMap<PublicKey, U512>>, Error>

Returns era_validators.

fn read_seigniorage_recipients(
    &mut self
) -> Result<BTreeMap<PublicKey, SeigniorageRecipient>, Error>

Returns validators in era_validators, mapped to their bids or founding stakes, delegation rates and lists of delegators together with their delegated quantities from delegators. This function is publicly accessible, but intended for system use by the Handle Payment contract, because this data is necessary for distributing seigniorage.

fn add_bid(
    &mut self,
    public_key: PublicKey,
    delegation_rate: u8,
    amount: U512
) -> Result<U512, Error>

For a non-founder validator, this adds, or modifies, an entry in the bids collection and calls bond in the Mint contract to create (or top off) a bid purse. It also adjusts the delegation rate.

fn withdraw_bid(
    &mut self,
    public_key: PublicKey,
    amount: U512
) -> Result<U512, Error>

For a non-founder validator, implements essentially the same logic as add_bid, but reducing the number of tokens and calling unbond in lieu of bond.

fn delegate(
    &mut self,
    delegator_public_key: PublicKey,
    validator_public_key: PublicKey,
    amount: U512
) -> Result<U512, Error>

Adds a new delegator to delegators, or tops off a current one. If the target validator is not in founders, the function call returns an error and does nothing.

fn undelegate(
    &mut self,
    delegator_public_key: PublicKey,
    validator_public_key: PublicKey,
    amount: U512
) -> Result<U512, Error>

Removes an amount of motes (or the entry altogether, if the remaining amount is 0) from the entry in delegators and calls unbond in the Mint contract to create a new unbonding purse.

fn slash(
    &mut self,
    validator_public_keys: Vec<PublicKey, Global>
) -> Result<(), Error>

Slashes each validator.

fn run_auction(
    &mut self,
    era_end_timestamp_millis: u64,
    evicted_validators: Vec<PublicKey, Global>
) -> Result<(), Error>

Takes active_bids and delegators to construct a list of validators’ total bids (their own added to their delegators’) ordered by size from largest to smallest, then takes the top N (number of auction slots) bidders and replaces era_validators with these.

fn distribute(
    &mut self,
    reward_factors: BTreeMap<PublicKey, u64>
) -> Result<(), Error>

Mint and distribute seigniorage rewards to validators and their delegators, according to reward_factors returned by the consensus component.

fn read_era_id(&mut self) -> Result<EraId, Error>

Reads current era id.

fn activate_bid(&mut self, validator_public_key: PublicKey) -> Result<(), Error>

Activates a given validator’s bid. To be used when a validator has been marked as inactive by consensus (aka “evicted”).

impl<'a, R> Externals for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn invoke_index(
    &mut self,
    index: usize,
    args: RuntimeArgs<'_>
) -> Result<Option<RuntimeValue>, Trap>

Perform invoke of a host function by specified index.

impl<'a, R> HandlePayment for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_payment_purse(&self) -> Result<URef, Error>

Get payment purse.

fn set_refund_purse(&mut self, purse: URef) -> Result<(), Error>

Set refund purse.

fn get_refund_purse(&self) -> Result<Option<URef>, Error>

Get refund purse.

fn finalize_payment(
    &mut self,
    amount_spent: U512,
    account: AccountHash,
    target: URef
) -> Result<(), Error>

Finalize payment with amount_spent and a given account.

impl<'a, R> HandlePaymentProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_payment_purse(&mut self) -> Result<URef, ApiError>

Get payment purse for given deploy.

impl<'a, R> Mint for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn mint(&mut self, initial_balance: U512) -> Result<URef, Error>

Mint new token with given initial_balance balance. Returns new purse on success, otherwise an error.

fn reduce_total_supply(&mut self, amount: U512) -> Result<(), Error>

Reduce total supply by amount. Returns unit on success, otherwise an error.

fn balance(&mut self, purse: URef) -> Result<Option<U512>, Error>

Read balance of given purse.

fn transfer(
    &mut self,
    maybe_to: Option<AccountHash>,
    source: URef,
    target: URef,
    amount: U512,
    id: Option<u64>
) -> Result<(), Error>

Transfers amount of tokens from source purse to a target purse.

fn read_base_round_reward(&mut self) -> Result<U512, Error>

Retrieves the base round reward.

impl<'a, R> MintProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn mint_transfer_direct(
    &mut self,
    to: Option<AccountHash>,
    source: URef,
    target: URef,
    amount: U512,
    id: Option<u64>
) -> Result<Result<(), Error>, Error>

Allows optimized auction and mint interaction. Intended to be used only by system contracts to manage staked purses. NOTE: Never expose this through FFI.

fn unbond(&mut self, unbonding_purse: &UnbondingPurse) -> Result<(), Error>

Returns successfully unbonded stake to origin account.

fn create_purse(&mut self) -> Result<URef, Error>

Creates new purse.

fn get_balance(&mut self, purse: URef) -> Result<Option<U512>, Error>

Gets purse balance.

fn read_base_round_reward(&mut self) -> Result<U512, Error>

Reads the base round reward.

fn mint(&mut self, amount: U512) -> Result<URef, Error>

Mints new token with given initial_balance balance. Returns new purse on success, otherwise an error.

fn reduce_total_supply(&mut self, amount: U512) -> Result<(), Error>

Reduce total supply by amount. Returns unit on success, otherwise an error.

impl<'a, R> MintProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn transfer_purse_to_account(
    &mut self,
    source: URef,
    target: AccountHash,
    amount: U512
) -> Result<TransferredTo, Error>

Transfer amount from source purse to a target account.

fn transfer_purse_to_purse(
    &mut self,
    source: URef,
    target: URef,
    amount: U512
) -> Result<(), Error>

Transfer amount from source purse to a target purse.

fn balance(&mut self, purse: URef) -> Result<Option<U512>, Error>

Checks balance of a purse. Returns None if given purse does not exist.

impl<'a, R> MintProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn transfer_purse_to_purse(
    &mut self,
    source: URef,
    target: URef,
    amount: U512
) -> Result<(), ApiError>

Transfer amount of tokens from source purse to a target purse.

impl<'a, R> RuntimeProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_caller(&self) -> AccountHash

This method should return the caller of the current context.

fn is_allowed_session_caller(&self, account_hash: &AccountHash) -> bool

Checks if account_hash matches the active session’s account.

fn named_keys_get(&self, name: &str) -> Option<Key>

Gets named key under a name.

fn get_keys(&mut self, key_tag: &KeyTag) -> Result<BTreeSet<Key>, Error>

Gets keys in a given keyspace

fn blake2b<T: AsRef<[u8]>>(&self, data: T) -> [u8; 32]

Returns a 32-byte BLAKE2b digest

impl<'a, R> RuntimeProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_caller(&self) -> AccountHash

This method should return the caller of the current context.

fn get_immediate_caller(&self) -> Option<&CallStackElement>

This method should return the immediate caller of the current context.

fn get_phase(&self) -> Phase

Gets execution phase

fn put_key(&mut self, name: &str, key: Key) -> Result<(), Error>

This method should handle storing given Key under name.

fn get_key(&self, name: &str) -> Option<Key>

This method should handle obtaining a given named Key under a name.

impl<'a, R> RuntimeProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn get_key(&self, name: &str) -> Option<Key>

Get named key under a name.

fn put_key(&mut self, name: &str, key: Key) -> Result<(), Error>

Put key under a name.

fn remove_key(&mut self, name: &str) -> Result<(), Error>

Remove a named key by name.

fn get_phase(&self) -> Phase

Get current execution phase.

fn get_block_time(&self) -> BlockTime

Get current block time.

fn get_caller(&self) -> AccountHash

Get caller.

impl<'a, R> StandardPayment for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn pay(&mut self, amount: U512) -> Result<(), ApiError>

Pay amount to a payment purse.

impl<'a, R> StorageProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn read<T: FromBytes + CLTyped>(
    &mut self,
    uref: URef
) -> Result<Option<T>, Error>

Reads data from URef.

fn write<T: ToBytes + CLTyped>(
    &mut self,
    uref: URef,
    value: T
) -> Result<(), Error>

Writes data to `URef.

fn read_bid(&mut self, account_hash: &AccountHash) -> Result<Option<Bid>, Error>

Reads Bid at account hash derived from given public key

fn write_bid(
    &mut self,
    account_hash: AccountHash,
    bid: Bid
) -> Result<(), Error>

Writes given Bid at account hash derived from given public key

fn read_withdraw(
    &mut self,
    account_hash: &AccountHash
) -> Result<Vec<UnbondingPurse>, Error>

Reads collection of UnbondingPurses at account hash derived from given public key

fn write_withdraw(
    &mut self,
    account_hash: AccountHash,
    unbonding_purses: Vec<UnbondingPurse>
) -> Result<(), Error>

Writes given UnbondingPurses at account hash derived from given public key

fn record_era_info(
    &mut self,
    era_id: EraId,
    era_info: EraInfo
) -> Result<(), Error>

Records era info at the given era id.

impl<'a, R> StorageProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn new_uref<T: CLTyped + ToBytes>(&mut self, init: T) -> Result<URef, Error>

Create new URef.

fn read<T: CLTyped + FromBytes>(
    &mut self,
    uref: URef
) -> Result<Option<T>, Error>

Read data from URef.

fn write<T: CLTyped + ToBytes>(
    &mut self,
    uref: URef,
    value: T
) -> Result<(), Error>

Write data under a URef.

fn add<T: CLTyped + ToBytes>(
    &mut self,
    uref: URef,
    value: T
) -> Result<(), Error>

Add data to a URef.

fn read_balance(&mut self, uref: URef) -> Result<Option<U512>, Error>

Read balance.

fn write_balance(&mut self, uref: URef, balance: U512) -> Result<(), Error>

Write balance.

fn add_balance(&mut self, uref: URef, value: U512) -> Result<(), Error>

Add amount to an existing balance.

impl<'a, R> SystemProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

fn record_transfer(
    &mut self,
    maybe_to: Option<AccountHash>,
    source: URef,
    target: URef,
    amount: U512,
    id: Option<u64>
) -> Result<(), Error>

Records a transfer.