1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
// Copyright (c) The Diem Core Contributors
// SPDX-License-Identifier: Apache-2.0
use crate::{data_cache::TransactionDataCache, runtime::VMRuntime};
use move_binary_format::errors::*;
use move_core_types::{
account_address::AccountAddress,
effects::{ChangeSet, Event},
identifier::IdentStr,
language_storage::{ModuleId, TypeTag},
resolver::MoveResolver,
value::MoveTypeLayout,
};
use move_vm_types::gas_schedule::GasStatus;
pub struct Session<'r, 'l, S> {
pub(crate) runtime: &'l VMRuntime,
pub(crate) data_cache: TransactionDataCache<'r, 'l, S>,
}
impl<'r, 'l, S: MoveResolver> Session<'r, 'l, S> {
/// Execute a Move function with the given arguments. This is mainly designed for an external
/// environment to invoke system logic written in Move.
///
/// The caller MUST ensure
/// - All types and modules referred to by the type arguments exist.
///
/// The Move VM MUST return an invariant violation if the caller fails to follow any of the
/// rules above.
///
/// Currently if any other error occurs during execution, the Move VM will simply propagate that
/// error back to the outer environment without handling/translating it. This behavior may be
/// revised in the future.
///
/// In case an invariant violation occurs, the whole Session should be considered corrupted and
/// one shall not proceed with effect generation.
pub fn execute_function(
&mut self,
module: &ModuleId,
function_name: &IdentStr,
ty_args: Vec<TypeTag>,
args: Vec<Vec<u8>>,
gas_status: &mut GasStatus,
) -> VMResult<Vec<Vec<u8>>> {
self.runtime.execute_function(
module,
function_name,
ty_args,
args,
&mut self.data_cache,
gas_status,
)
}
/// Execute a Move script function with the given arguments.
///
/// Unlike `execute_function` which is designed for system logic, `execute_script_function` is
/// mainly designed to call a script function in an existing module. It similar to
/// `execute_script` except that execution of the "script" begins with the specified function
///
/// The Move VM MUST return a user error (in other words, an error that's not an invariant
/// violation) if
/// - The function does not exist.
/// - The function does not have script visibility.
/// - The signature is not valid for a script. Not all script-visible module functions can
/// be invoked from this entry point. See `bytecode_verifier::script_signature` for the
/// rules.
/// - Type arguments refer to a non-existent type.
/// - Arguments (senders included) fail to deserialize or fail to match the signature of the
/// script function.
///
/// If any other error occurs during execution, the Move VM MUST propagate that error back to
/// the caller.
/// Besides, no user input should cause the Move VM to return an invariant violation.
///
/// In case an invariant violation occurs, the whole Session should be considered corrupted and
/// one shall not proceed with effect generation.
pub fn execute_script_function(
&mut self,
module: &ModuleId,
function_name: &IdentStr,
ty_args: Vec<TypeTag>,
args: Vec<Vec<u8>>,
senders: Vec<AccountAddress>,
gas_status: &mut GasStatus,
) -> VMResult<()> {
self.runtime.execute_script_function(
module,
function_name,
ty_args,
args,
senders,
&mut self.data_cache,
gas_status,
)
}
/// Execute a transaction script.
///
/// The Move VM MUST return a user error (in other words, an error that's not an invariant
/// violation) if
/// - The script fails to deserialize or verify. Not all expressible signatures are valid.
/// See `bytecode_verifier::script_signature` for the rules.
/// - Type arguments refer to a non-existent type.
/// - Arguments (senders included) fail to deserialize or fail to match the signature of the
/// script function.
///
/// If any other error occurs during execution, the Move VM MUST propagate that error back to
/// the caller.
/// Besides, no user input should cause the Move VM to return an invariant violation.
///
/// In case an invariant violation occurs, the whole Session should be considered corrupted and
/// one shall not proceed with effect generation.
pub fn execute_script(
&mut self,
script: Vec<u8>,
ty_args: Vec<TypeTag>,
args: Vec<Vec<u8>>,
senders: Vec<AccountAddress>,
gas_status: &mut GasStatus,
) -> VMResult<()> {
self.runtime.execute_script(
script,
ty_args,
args,
senders,
&mut self.data_cache,
gas_status,
)
}
/// Publish the given module.
///
/// The Move VM MUST return a user error, i.e., an error that's not an invariant violation, if
/// - The module fails to deserialize or verify.
/// - The sender address does not match that of the module.
/// - (Republishing-only) the module to be updated is not backward compatible with the old module.
/// - (Republishing-only) the module to be updated introduces cyclic dependencies.
///
/// The Move VM should not be able to produce other user errors.
/// Besides, no user input should cause the Move VM to return an invariant violation.
///
/// In case an invariant violation occurs, the whole Session should be considered corrupted and
/// one shall not proceed with effect generation.
pub fn publish_module(
&mut self,
module: Vec<u8>,
sender: AccountAddress,
gas_status: &mut GasStatus,
) -> VMResult<()> {
self.publish_module_bundle(vec![module], sender, gas_status)
}
/// Publish a series of modules.
///
/// The Move VM MUST return a user error, i.e., an error that's not an invariant violation, if
/// any module fails to deserialize or verify (see the full list of failing conditions in the
/// `publish_module` API). The publishing of the module series is an all-or-nothing action:
/// either all modules are published to the data store or none is.
///
/// Similar to the `publish_module` API, the Move VM should not be able to produce other user
/// errors. Besides, no user input should cause the Move VM to return an invariant violation.
///
/// In case an invariant violation occurs, the whole Session should be considered corrupted and
/// one shall not proceed with effect generation.
pub fn publish_module_bundle(
&mut self,
modules: Vec<Vec<u8>>,
sender: AccountAddress,
gas_status: &mut GasStatus,
) -> VMResult<()> {
self.runtime
.publish_module_bundle(modules, sender, &mut self.data_cache, gas_status)
}
pub fn num_mutated_accounts(&self, sender: &AccountAddress) -> u64 {
self.data_cache.num_mutated_accounts(sender)
}
/// Finish up the session and produce the side effects.
///
/// This function should always succeed with no user errors returned, barring invariant violations.
///
/// This MUST NOT be called if there is a previous invocation that failed with an invariant violation.
pub fn finish(self) -> VMResult<(ChangeSet, Vec<Event>)> {
self.data_cache
.into_effects()
.map_err(|e| e.finish(Location::Undefined))
}
pub fn get_type_layout(&self, type_tag: &TypeTag) -> VMResult<MoveTypeLayout> {
self.runtime
.loader()
.get_type_layout(type_tag, &self.data_cache)
}
}