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>
) -> 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 is_mint(&self, key: Key) -> bool

pub fn is_proof_of_stake(&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]
) -> Result<CLValue, Error>

pub fn call_host_proof_of_stake(
    &mut self,
    protocol_version: ProtocolVersion,
    entry_point_name: &str,
    named_keys: &mut NamedKeys,
    runtime_args: &RuntimeArgs,
    extra_keys: &[Key]
) -> 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]
) -> 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>, 

pub 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>, 

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

Returns era_validators.

pub 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 PoS contract, because this data is necessary for distributing seigniorage.

pub fn add_bid(
    &mut self,
    public_key: PublicKey,
    source: URef,
    delegation_rate: u64,
    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.

pub fn withdraw_bid(
    &mut self,
    public_key: PublicKey,
    amount: U512,
    unbonding_purse: URef
) -> 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.

pub fn delegate(
    &mut self,
    delegator_public_key: PublicKey,
    source: URef,
    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.

pub fn undelegate(
    &mut self,
    delegator_public_key: PublicKey,
    validator_public_key: PublicKey,
    amount: U512,
    unbonding_purse: URef
) -> 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.

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

Slashes each validator.

pub fn run_auction(&mut self) -> 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.

pub 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.

pub fn withdraw_delegator_reward(
    &mut self,
    validator_public_key: PublicKey,
    delegator_public_key: PublicKey,
    target_purse: URef
) -> Result<U512, Error>

Allows delegators to withdraw the seigniorage rewards they have earned. Pays out the entire accumulated amount to the destination purse.

pub fn withdraw_validator_reward(
    &mut self,
    validator_public_key: PublicKey,
    target_purse: URef
) -> Result<U512, Error>

Allows validators to withdraw the seigniorage rewards they have earned. Pays out the entire accumulated amount to the destination purse.

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

Reads current era id.

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

pub 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> Mint for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

pub 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.

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

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

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

Read balance of given purse.

pub 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.

pub 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>, 

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

Transfers amount from source purse to a target account.

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

Transfers amount from source purse to a target purse.

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

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

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

Reads the base round reward.

pub 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.

pub 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>, 

pub 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.

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

Transfer amount from source purse to a target purse.

pub 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>, 

pub 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> ProofOfStake for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

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

Get payment purse.

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

Set refund purse.

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

Get refund purse.

pub 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> ProofOfStakeProvider for Runtime<'a, R> where
    R: StateReader<Key, StoredValue>,
    R::Error: Into<Error>, 

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

Get payment purse for given deploy.

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

pub fn get_caller(&self) -> AccountHash

This method should return the caller of the current context.

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

Gets named key under a name.

pub 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>, 

pub fn get_caller(&self) -> AccountHash

This method should return the caller of the current context.

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

This method should handle storing given Key under name.

pub 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>, 

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

Get named key under a name.

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

Put key under a name.

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

Remove a named key by name.

pub fn get_phase(&self) -> Phase

Get current execution phase.

pub fn get_block_time(&self) -> BlockTime

Get current block time.

pub fn get_caller(&self) -> AccountHash

Get caller.

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

pub 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>, 

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

Reads data from URef.

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

Writes data to `URef.

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

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

Create new URef.

pub fn write_local<K: ToBytes, V: CLTyped + ToBytes>(
    &mut self,
    key: K,
    value: V
) -> Result<(), Error>

Write data to a local key.

pub fn read_local<K: ToBytes, V: CLTyped + FromBytes>(
    &mut self,
    key: &K
) -> Result<Option<V>, Error>

Read data from a local key.

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

Read data from URef.

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

Write data under a URef.

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

Add data to a URef.

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

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

Creates new purse.

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

Gets purse balance.

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

Transfers specified amount of tokens from source purse into a target purse.

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

Records era info at the given era id.

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

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

Records a transfer.