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(
    state: Rc<RefCell<TrackingCopy<R>>>,
    named_keys: &'a mut BTreeMap<String, Key>,
    access_rights: HashMap<Address, HashSet<AccessRights>>,
    args: Vec<CLValue>,
    authorization_keys: BTreeSet<PublicKey>,
    account: &'a Account,
    base_key: Key,
    blocktime: BlockTime,
    deploy_hash: [u8; 32],
    gas_limit: Gas,
    gas_counter: Gas,
    fn_store_id: u32,
    address_generator: Rc<RefCell<AddressGenerator>>,
    protocol_version: ProtocolVersion,
    correlation_id: CorrelationId,
    phase: Phase,
    protocol_data: ProtocolData
) -> Self

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

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

pub fn named_keys(&self) -> &BTreeMap<String, Key>

pub fn fn_store_id(&self) -> u32

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) -> PublicKey

pub fn get_blocktime(&self) -> BlockTime

pub fn get_deployhash(&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) -> &Vec<CLValue>

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

pub fn base_key(&self) -> Key

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

pub fn protocol_version(&self) -> ProtocolVersion

pub fn correlation_id(&self) -> CorrelationId

pub fn phase(&self) -> Phase

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

Generates new function address. Function address is deterministic. It is a hash of public key, nonce and fn_store_id, which is a counter that is being incremented after every function generation. If function address was based only on account's public key and deploy's nonce, then all function addresses generated within one deploy would have been the same.

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: &[u8]) -> Result<Option<CLValue>, Error>

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

DO NOT EXPOSE THIS VIA THE FFI

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_ls(
    &mut self,
    key_bytes: &[u8],
    cl_value: CLValue
) -> Result<(), Error>

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

pub fn remove_associated_key(
    &mut self,
    public_key: PublicKey
) -> Result<(), Error>

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

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

pub fn upgrade_contract_at_uref(
    &mut self,
    key: Key,
    bytes: Vec<u8>,
    named_keys: BTreeMap<String, Key>
) -> Result<(), Error>

pub fn protocol_data(&self) -> ProtocolData

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

Gets main purse id

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,
    dest: 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) -> PublicKey

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>