Struct ethcore::executive::Executive

pub struct Executive<'a, B: 'a> { /* private fields */ }

Transaction executor.

Implementations

impl<'a, B: 'a + StateBackend> Executive<'a, B>

pub fn new(
    state: &'a mut State<B>,
    info: &'a EnvInfo,
    machine: &'a Machine,
    schedule: &'a Schedule
) -> Self

Basic constructor.

pub fn from_parent(
    state: &'a mut State<B>,
    info: &'a EnvInfo,
    machine: &'a Machine,
    schedule: &'a Schedule,
    parent_depth: usize,
    static_flag: bool
) -> Self

Populates executive from parent properties. Increments executive depth.

pub fn transact<T, V>(
    &'a mut self,
    t: &SignedTransaction,
    options: TransactOptions<T, V>
) -> Result<Executed<T::Output, V::Output>, ExecutionError> where
    T: Tracer,
    V: VMTracer, 

This function should be used to execute transaction.

pub fn transact_virtual<T, V>(
    &'a mut self,
    t: &SignedTransaction,
    options: TransactOptions<T, V>
) -> Result<Executed<T::Output, V::Output>, ExecutionError> where
    T: Tracer,
    V: VMTracer, 

Execute a transaction in a “virtual” context. This will ensure the caller has enough balance to execute the desired transaction. Used for extra-block executions for things like consensus contracts and RPCs

pub fn call_with_stack_depth<T, V>(
    &mut self,
    params: ActionParams,
    substate: &mut Substate,
    stack_depth: usize,
    tracer: &mut T,
    vm_tracer: &mut V
) -> Result<FinalizationResult> where
    T: Tracer,
    V: VMTracer, 

Calls contract function with given contract params and stack depth. NOTE. It does not finalize the transaction (doesn’t do refunds, nor suicides). Modifies the substate and the output. Returns either gas_left or vm::Error.

pub fn call<T, V>(
    &mut self,
    params: ActionParams,
    substate: &mut Substate,
    tracer: &mut T,
    vm_tracer: &mut V
) -> Result<FinalizationResult> where
    T: Tracer,
    V: VMTracer, 

Calls contract function with given contract params.

pub fn create_with_stack_depth<T, V>(
    &mut self,
    params: ActionParams,
    substate: &mut Substate,
    stack_depth: usize,
    tracer: &mut T,
    vm_tracer: &mut V
) -> Result<FinalizationResult> where
    T: Tracer,
    V: VMTracer, 

Creates contract with given contract params and stack depth. NOTE. It does not finalize the transaction (doesn’t do refunds, nor suicides). Modifies the substate.

pub fn create<T, V>(
    &mut self,
    params: ActionParams,
    substate: &mut Substate,
    tracer: &mut T,
    vm_tracer: &mut V
) -> Result<FinalizationResult> where
    T: Tracer,
    V: VMTracer, 

Creates contract with given contract params.