Struct casperlabs_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 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_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, ApiError>

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

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

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

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>

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

fn bond(
    &mut self,
    validator: AccountHash,
    amount: U512,
    source: URef
) -> Result<(), Error>

fn unbond(
    &mut self,
    validator: AccountHash,
    maybe_amount: Option<U512>
) -> Result<(), Error>

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

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

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

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

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

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

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

fn read_bonding(&mut self) -> Queue

Reads bonding queue.

fn read_unbonding(&mut self) -> Queue

Reads unbonding queue.

fn write_bonding(&mut self, queue: Queue)

Writes bonding queue.

fn write_unbonding(&mut self, queue: Queue)

Writes unbonding queue.

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>

fn put_key(&mut self, name: &str, key: Key)

fn remove_key(&mut self, name: &str)

fn get_phase(&self) -> Phase

fn get_block_time(&self) -> BlockTime

fn get_caller(&self) -> AccountHash

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

fn read(&self) -> Result<Stakes, Error>

fn write(&mut self, stakes: &Stakes)

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>