Struct casperlabs_engine_core::runtime_context::RuntimeContext

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

Holds information specific to the deployed contract.

Implementations

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

pub fn new(
    tracking_copy: Rc<RefCell<TrackingCopy<R>>>,
    entry_point_type: EntryPointType,
    named_keys: &'a mut NamedKeys,
    access_rights: HashMap<Address, HashSet<AccessRights>>,
    runtime_args: RuntimeArgs,
    authorization_keys: BTreeSet<AccountHash>,
    account: &'a Account,
    base_key: Key,
    blocktime: BlockTime,
    deploy_hash: [u8; 32],
    gas_limit: Gas,
    gas_counter: Gas,
    hash_address_generator: Rc<RefCell<AddressGenerator>>,
    uref_address_generator: Rc<RefCell<AddressGenerator>>,
    protocol_version: ProtocolVersion,
    correlation_id: CorrelationId,
    phase: Phase,
    protocol_data: ProtocolData
) -> Self

pub fn authorization_keys(&self) -> &BTreeSet<AccountHash>

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

pub fn named_keys(&self) -> &NamedKeys

pub fn named_keys_mut(&mut self) -> &mut NamedKeys

pub fn named_keys_contains_key(&self, name: &str) -> bool

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

Remove Key from the named_keys map of the current context. It removes both from the ephemeral map (RuntimeContext::named_keys) but also persistable map (one that is found in the TrackingCopy/GlobalState).

pub fn get_caller(&self) -> AccountHash

pub fn get_blocktime(&self) -> BlockTime

pub fn get_deploy_hash(&self) -> [u8; 32]

pub fn access_rights_extend(
    &mut self,
    access_rights: HashMap<Address, HashSet<AccessRights>>
)

pub fn account(&self) -> &'a Account

pub fn args(&self) -> &RuntimeArgs

pub fn uref_address_generator(&self) -> Rc<RefCell<AddressGenerator>>

pub fn hash_address_generator(&self) -> Rc<RefCell<AddressGenerator>>

pub fn state(&self) -> Rc<RefCell<TrackingCopy<R>>>

pub fn gas_limit(&self) -> Gas

pub fn gas_counter(&self) -> Gas

pub fn set_gas_counter(&mut self, new_gas_counter: Gas)

pub fn base_key(&self) -> Key

pub fn protocol_version(&self) -> ProtocolVersion

pub fn correlation_id(&self) -> CorrelationId

pub fn phase(&self) -> Phase

pub fn new_hash_address(&mut self) -> Result<[u8; 32], Error>

Generates new deterministic hash for uses as an address.

pub fn new_uref(&mut self, value: StoredValue) -> Result<URef, Error>

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

Puts key to the map of named keys of current context.

pub fn read_ls(&mut self, key_bytes: &[u8]) -> Result<Option<CLValue>, Error>

pub fn write_ls(
    &mut self,
    key_bytes: &[u8],
    cl_value: CLValue
) -> Result<(), Error>

pub fn read_gs(&mut self, key: &Key) -> Result<Option<StoredValue>, Error>

pub fn read_gs_direct(
    &mut self,
    key: &Key
) -> Result<Option<StoredValue>, Error>

DO NOT EXPOSE THIS VIA THE FFI

pub fn read_gs_typed<T>(&mut self, key: &Key) -> Result<T, Error> where
    T: TryFrom<StoredValue>,
    T::Error: Debug, 

This method is a wrapper over read_gs in the sense that it extracts the type held by a StoredValue stored in the global state in a type safe manner.

This is useful if you want to get the exact type from global state.

pub fn write_gs(&mut self, key: Key, value: StoredValue) -> Result<(), Error>

pub fn read_account(&mut self, key: &Key) -> Result<Option<StoredValue>, Error>

pub fn write_account(&mut self, key: Key, account: Account) -> Result<(), Error>

pub fn store_function(
    &mut self,
    contract: StoredValue
) -> Result<[u8; 32], Error>

pub fn store_function_at_hash(
    &mut self,
    contract: StoredValue
) -> Result<[u8; 32], Error>

pub fn insert_key(&mut self, name: String, key: Key)

pub fn insert_uref(&mut self, uref: URef)

pub fn effect(&self) -> ExecutionEffect

pub fn validate_key(&self, key: &Key) -> Result<(), Error>

Validates whether key is not forged (whether it can be found in the named_keys) and whether the version of a key that contract wants to use, has access rights that are less powerful than access rights' of the key in the named_keys.

pub fn validate_uref(&self, uref: &URef) -> Result<(), Error>

pub fn deserialize_keys(&self, bytes: Vec<u8>) -> Result<Vec<Key>, Error>

pub fn deserialize_urefs(&self, bytes: Vec<u8>) -> Result<Vec<URef>, Error>

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

Tests whether reading from the key is valid.

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

Tests whether addition to key is valid.

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

Tests whether writing to key is valid.

pub fn add_gs(&mut self, key: Key, value: StoredValue) -> Result<(), Error>

Adds value to the key. The premise for being able to add value is that the type of it [value] can be added (is a Monoid). If the values can't be added, either because they're not a Monoid or if the value stored under key has different type, then TypeMismatch errors is returned.

pub fn add_associated_key(
    &mut self,
    account_hash: AccountHash,
    weight: Weight
) -> Result<(), Error>

pub fn remove_associated_key(
    &mut self,
    account_hash: AccountHash
) -> Result<(), Error>

pub fn update_associated_key(
    &mut self,
    account_hash: AccountHash,
    weight: Weight
) -> Result<(), Error>

pub fn set_action_threshold(
    &mut self,
    action_type: ActionType,
    threshold: Weight
) -> Result<(), Error>

pub fn protocol_data(&self) -> ProtocolData

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

Gets main purse id

pub fn entry_point_type(&self) -> EntryPointType

Gets entry point type.

Trait Implementations

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

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

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

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

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

fn get_caller(&self) -> AccountHash

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

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

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

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

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

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

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

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