Struct casper_execution_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: DeployHash,
    gas_limit: Gas,
    gas_counter: Gas,
    hash_address_generator: Rc<RefCell<AddressGenerator>>,
    uref_address_generator: Rc<RefCell<AddressGenerator>>,
    transfer_address_generator: Rc<RefCell<AddressGenerator>>,
    protocol_version: ProtocolVersion,
    correlation_id: CorrelationId,
    phase: Phase,
    protocol_data: ProtocolData,
    transfers: Vec<TransferAddr>
) -> 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) -> DeployHash

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

pub fn access_rights(&self) -> &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 transfer_address_generator(&self) -> Rc<RefCell<AddressGenerator>>

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 new_transfer_addr(&mut self) -> Result<TransferAddr, 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 read_account(&mut self, key: &Key) -> Result<Option<StoredValue>, Error>

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

pub fn write_transfer(&mut self, key: Key, value: Transfer)

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 transfers(&self) -> &Vec<TransferAddr>

pub fn transfers_mut(&mut self) -> &mut Vec<TransferAddr>

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 metered_write_gs<T>(&mut self, key: Key, value: T) -> Result<(), Error> where
    T: Into<StoredValue>, 

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.