Struct sp_state_machine::StateMachine

pub struct StateMachine<'a, B, H, N, Exec> where
    H: Hasher,
    B: Backend<H>,
    N: ChangesTrieBlockNumber,  { /* fields omitted */ }

The substrate state machine.

Implementations

impl<'a, B, H, N, Exec> StateMachine<'a, B, H, N, Exec> where
    H: Hasher,
    H::Out: Ord + 'static + Codec,
    Exec: CodeExecutor + Clone + 'static,
    B: Backend<H>,
    N: BlockNumber, 

pub fn new(
    backend: &'a B,
    changes_trie_state: Option<ChangesTrieState<'a, H, N>>,
    overlay: &'a mut OverlayedChanges,
    offchain_overlay: &'a mut OffchainOverlayedChanges,
    exec: &'a Exec,
    method: &'a str,
    call_data: &'a [u8],
    extensions: Extensions,
    runtime_code: &'a RuntimeCode<'_>,
    spawn_handle: Box<dyn CloneableSpawn>
) -> Self

Creates new substrate state machine.

pub fn with_storage_transaction_cache(
    self,
    cache: Option<&'a mut StorageTransactionCache<B::Transaction, H, N>>
) -> Self

Use given cache as storage transaction cache.

The cache will be used to cache storage transactions that can be build while executing a function in the runtime. For example, when calculating the storage root a transaction is build that will be cached.

pub fn execute(
    &mut self,
    strategy: ExecutionStrategy
) -> Result<Vec<u8>, Box<dyn Error>>

Execute a call using the given state backend, overlayed changes, and call executor.

On an error, no prospective changes are written to the overlay.

Note: changes to code will be in place if this call is made again. For running partial blocks (e.g. a transaction at a time), ensure a different method is used.

Returns the SCALE encoded result of the executed function.

pub fn execute_using_consensus_failure_handler<Handler, R, NC>(
    &mut self,
    manager: ExecutionManager<Handler>,
    native_call: Option<NC>
) -> Result<NativeOrEncoded<R>, Box<dyn Error>> where
    R: Decode + Encode + PartialEq,
    NC: FnOnce() -> Result<R, String> + UnwindSafe,
    Handler: FnOnce(Result<NativeOrEncoded<R>, Exec::Error>, Result<NativeOrEncoded<R>, Exec::Error>) -> Result<NativeOrEncoded<R>, Exec::Error>, 

Execute a call using the given state backend, overlayed changes, and call executor.

On an error, no prospective changes are written to the overlay.

Note: changes to code will be in place if this call is made again. For running partial blocks (e.g. a transaction at a time), ensure a different method is used.

Returns the result of the executed function either in native representation R or in SCALE encoded representation.

Trait Implementations

impl<'a, B, H, N, Exec> Drop for StateMachine<'a, B, H, N, Exec> where
    H: Hasher,
    B: Backend<H>,
    N: ChangesTrieBlockNumber, 

fn drop(&mut self)

Executes the destructor for this type.