Struct solana_libra_vm_runtime::txn_executor::TransactionExecutor

pub struct TransactionExecutor<'alloc, 'txn, P> where
    'alloc: 'txn,
    P: ModuleCache<'alloc>,  { /* fields omitted */ }

A struct that executes one single transaction. 'alloc is the lifetime for the code cache, which is the argument type P here. Hence the P should live as long as alloc. 'txn is the lifetime of one single transaction. execution_stack contains the call stack and value stack of current execution. txn_data contains the information of this transaction, such as sender, sequence number, etc. event_data is the vector that stores all events emitted during execution. data_view is the scratchpad for the local writes emitted by this transaction.

Methods

impl<'alloc, 'txn, P> TransactionExecutor<'alloc, 'txn, P> where
    'alloc: 'txn,
    P: ModuleCache<'alloc>, 

pub fn new(
    module_cache: P,
    data_cache: &'txn dyn RemoteCache,
    txn_data: TransactionMetadata
) -> Self

Create a new TransactionExecutor to execute a single transaction. module_cache is the cache that stores the modules previously read from the blockchain. data_cache is the cache that holds read-only connection to the state store as well as the changes made by previous transactions within the same block.

pub fn module_cache(&self) -> &P

Returns the module cache for this executor.

pub fn execute_block(
    &mut self,
    code: &[Bytecode],
    beginning_offset: CodeOffset
) -> VMResult<CodeOffset>

This function will execute the code sequence starting from the beginning_offset, and return Ok(Ok(offset)) when the instruction sequence hit a branch, either by calling into a new function, branches, function return, etc. The return value will be the pc for the next instruction to be executed.

pub fn create_account(&mut self, addr: AccountAddress) -> VMResult<()>

Create an account on the blockchain by calling into CREATE_ACCOUNT_NAME function stored in the ACCOUNT_MODULE on chain.

pub fn execute_function(
    &mut self,
    module: &ModuleId,
    function_name: &str,
    args: Vec<Local>
) -> VMResult<()>

Execute a function. module is an identifier for the name the module is stored in. function_name is the name of the function. If such function is found, the VM will execute this function with arguments args. The return value will be placed on the top of the value stack and abort if an error occurs.

pub fn pop_stack(&mut self) -> Result<Local, VMInvariantViolation>

Get the value on the top of the value stack.

pub fn make_write_set(
    &mut self,
    to_be_published_modules: Vec<(ModuleId, Vec<u8>)>,
    result: VMResult<()>
) -> VMRuntimeResult<TransactionOutput>

Produce a write set at the end of a transaction. This will clear all the local states in the TransactionProcessor and turn them into a writeset.