Struct ExecutionContext

pub struct ExecutionContext<'vm, 'state, 'a> {
    pub protocol_config: &'a ProtocolConfig,
    pub metrics: Arc<LimitsMetrics>,
    pub vm: &'vm MoveVM,
    pub linkage_view: LinkageView<'state>,
    pub native_extensions: NativeContextExtensions<'state>,
    pub state_view: &'state dyn ExecutionState,
    pub tx_context: Rc<RefCell<TxContext>>,
    pub gas_charger: &'a mut GasCharger,
    /* private fields */
}

Maintains all runtime state specific to programmable transactions

Fields

protocol_config: &'a ProtocolConfig

The protocol config

metrics: Arc<LimitsMetrics>

Metrics for reporting exceeded limits

vm: &'vm MoveVM

The MoveVM

linkage_view: LinkageView<'state>

The LinkageView for this session

native_extensions: NativeContextExtensions<'state>

state_view: &'state dyn ExecutionState

The global state, used for resolving packages

tx_context: Rc<RefCell<TxContext>>

A shared transaction context, contains transaction digest information and manages the creation of new object IDs

gas_charger: &'a mut GasCharger

The gas charger used for metering

Implementations

impl<'vm, 'state, 'a> ExecutionContext<'vm, 'state, 'a>

pub fn new( protocol_config: &'a ProtocolConfig, metrics: Arc<LimitsMetrics>, vm: &'vm MoveVM, state_view: &'state dyn ExecutionState, tx_context: Rc<RefCell<TxContext>>, gas_charger: &'a mut GasCharger, inputs: Vec<CallArg>, ) -> Result<Self, ExecutionError>

where 'a: 'state,

pub fn object_runtime(&self) -> Result<&ObjectRuntime<'_>, ExecutionError>

pub fn fresh_id(&mut self) -> Result<ObjectID, ExecutionError>

Create a new ID and update the state

pub fn delete_id(&mut self, object_id: ObjectID) -> Result<(), ExecutionError>

Delete an ID and update the state

pub fn set_link_context( &mut self, package_id: ObjectID, ) -> Result<AccountAddress, ExecutionError>

Set the link context for the session from the linkage information in the MovePackage found at package_id. Returns the runtime ID of the link context package on success.

pub fn load_type(&mut self, type_tag: &TypeTag) -> VMResult<Type>

Load a type using the context’s current session.

pub fn load_type_from_struct( &mut self, struct_tag: &StructTag, ) -> VMResult<Type>

Load a type using the context’s current session.

pub fn get_type_abilities(&self, t: &Type) -> Result<AbilitySet, ExecutionError>

pub fn take_user_events( &mut self, module_id: &ModuleId, function: FunctionDefinitionIndex, last_offset: CodeOffset, ) -> Result<(), ExecutionError>

Takes the user events from the runtime and tags them with the Move module of the function that was invoked for the command

pub fn splat_args<Items: IntoIterator<Item = Argument>>( &self, start_idx: usize, args: Items, ) -> Result<Vec<Arg>, ExecutionError>

where Items::IntoIter: ExactSizeIterator,

Takes an iterator of arguments and flattens a Result into a NestedResult if there is more than one result. However, it is currently gated to 1 result, so this function is in place for future changes. This is currently blocked by more invasive work needed to update argument idx in errors

pub fn one_arg( &self, command_arg_idx: usize, arg: Argument, ) -> Result<Arg, ExecutionError>

pub fn by_value_arg<V: TryFromValue>( &mut self, command_kind: CommandKind<'_>, arg_idx: usize, arg: Arg, ) -> Result<V, ExecutionError>

Get the argument value. Cloning the value if it is copyable, and setting its value to None if it is not (making it unavailable). Errors if out of bounds, if the argument is borrowed, if it is unavailable (already taken), or if it is an object that cannot be taken by value (shared or immutable)

pub fn borrow_arg_mut<V: TryFromValue>( &mut self, arg_idx: usize, arg: Arg, ) -> Result<V, ExecutionError>

Mimic a mutable borrow by taking the argument value, setting its value to None, making it unavailable. The value will be marked as borrowed and must be returned with restore_arg Errors if out of bounds, if the argument is borrowed, if it is unavailable (already taken), or if it is an object that cannot be mutably borrowed (immutable)

pub fn borrow_arg<V: TryFromValue>( &mut self, arg_idx: usize, arg: Arg, type_: &Type, ) -> Result<V, ExecutionError>

Mimics an immutable borrow by cloning the argument value without setting its value to None Errors if out of bounds, if the argument is mutably borrowed, or if it is unavailable (already taken)

pub fn restore_arg<Mode: ExecutionMode>( &mut self, updates: &mut Mode::ArgumentUpdates, arg: Arg, value: Value, ) -> Result<(), ExecutionError>

Restore an argument after being mutably borrowed

pub fn transfer_object( &mut self, obj: ObjectValue, addr: SuiAddress, ) -> Result<(), ExecutionError>

Transfer the object to a new owner

pub fn new_package<'p>( &self, modules: &[CompiledModule], dependencies: impl IntoIterator<Item = &'p MovePackage>, ) -> Result<MovePackage, ExecutionError>

Create a new package

pub fn upgrade_package<'p>( &self, storage_id: ObjectID, previous_package: &MovePackage, new_modules: &[CompiledModule], dependencies: impl IntoIterator<Item = &'p MovePackage>, ) -> Result<MovePackage, ExecutionError>

Create a package upgrade from previous_package with new_modules and dependencies

pub fn write_package(&mut self, package: MovePackage)

Add a newly created package to write as an effect of the transaction

pub fn pop_package(&mut self) -> Option<MovePackage>

Return the last package pushed in write_package. This function should be used in block of codes that push a package, verify it, run the init and in case of error will remove the package. The package has to be pushed for the init to run correctly.

pub fn push_command_results( &mut self, results: Vec<Value>, ) -> Result<(), ExecutionError>

Finish a command: clearing the borrows and adding the results to the result vector

pub fn finish<Mode: ExecutionMode>( self, ) -> Result<ExecutionResults, ExecutionError>

Determine the object changes and collect all user events

pub fn convert_vm_error(&self, error: VMError) -> ExecutionError

Convert a VM Error to an execution one

pub fn convert_type_argument_error( &self, idx: usize, error: VMError, ) -> ExecutionError

Special case errors for type arguments to Move functions

pub fn publish_module_bundle( &mut self, modules: Vec<Vec<u8>>, sender: AccountAddress, ) -> VMResult<()>

pub fn size_bound_raw(&self, bound: u64) -> SizeBound

pub fn size_bound_vector_elem(&self, bound: u64) -> SizeBound

Trait Implementations

impl TypeTagResolver for ExecutionContext<'_, '_, '_>

fn get_type_tag(&self, type_: &Type) -> Result<TypeTag, ExecutionError>