Struct ExecutionContext

pub struct ExecutionContext<'vm, 'state, 'a> {
    pub protocol_config: &'a ProtocolConfig,
    pub metrics: Arc<LimitsMetrics>,
    pub vm: &'vm MoveVM,
    pub state_view: &'state dyn ExecutionState,
    pub tx_context: &'a mut TxContext,
    pub gas_charger: &'a mut GasCharger,
    pub session: Session<'state, 'vm, LinkageView<'state>>,
    /* 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

state_view: &'state dyn ExecutionState

The global state, used for resolving packages

tx_context: &'a mut 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

session: Session<'state, 'vm, LinkageView<'state>>

The session used for interacting with Move types and calls

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: &'a mut TxContext, gas_charger: &'a mut GasCharger, inputs: Vec<CallArg>, ) -> Result<Self, 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 set_linkage( &mut self, package: &MovePackage, ) -> Result<AccountAddress, ExecutionError>

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

pub fn reset_linkage(&mut self)

Turn off linkage information, so that the next use of the session will need to set linkage information to succeed.

pub fn steal_linkage(&mut self) -> Option<SavedLinkage>

Reset the linkage context, and save it (if one exists)

pub fn restore_linkage( &mut self, saved: Option<SavedLinkage>, ) -> Result<(), ExecutionError>

Restore a previously stolen/saved link context.

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

Load a type using the context’s current session.

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 by_value_arg<V: TryFromValue>( &mut self, command_kind: CommandKind<'_>, arg_idx: usize, arg: Argument, ) -> 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: Argument, ) -> 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: Argument, ) -> 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: Argument, 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<Object, 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<Object, ExecutionError>

Create a package upgrade from previous_package with new_modules and dependencies

pub fn write_package(&mut self, package: Object) -> Result<(), ExecutionError>

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

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

Trait Implementations

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

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