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,
    named_keys: BTreeMap<String, Key>,
    args: &[CLValue],
    extra_urefs: &[Key]
) -> Result<CLValue, Error>

pub fn call_host_proof_of_stake(
    &mut self,
    protocol_version: ProtocolVersion,
    named_keys: BTreeMap<String, Key>,
    args: &[CLValue],
    extra_urefs: &[Key]
) -> Result<CLValue, Error>

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

pub fn call_contract(
    &mut self,
    key: Key,
    args_bytes: Vec<u8>
) -> Result<CLValue, Error>

Calls contract living under a key, with supplied args.

pub fn add_local(
    &mut self,
    key_ptr: u32,
    key_size: u32,
    value_ptr: u32,
    value_size: u32
) -> Result<(), Trap>

Adds value to the cell pointed to by a key derived from key in the "local cluster" of GlobalState

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: PublicKey,
    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: PublicKey,
    amount: U512,
    source: URef
) -> Result<(), Error>

fn unbond(
    &mut self,
    validator: PublicKey,
    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: PublicKey
) -> 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) -> PublicKey

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>