Trait polkadot_service::CallExecutor

pub trait CallExecutor<B>: RuntimeVersionOfwhere
    B: Block,{
    type Error: Error;
    type Backend: Backend<B>;

    fn call(
        &self,
        id: &BlockId<B>,
        method: &str,
        call_data: &[u8],
        strategy: ExecutionStrategy,
        extensions: Option<Extensions>
    ) -> Result<Vec<u8, Global>, Error>;
    fn contextual_call<EM, R, NC>(
        &self,
        at: &BlockId<B>,
        method: &str,
        call_data: &[u8],
        changes: &RefCell<OverlayedChanges>,
        storage_transaction_cache: Option<&RefCell<StorageTransactionCache<<<Self::Backend as Backend<B>>::State as Backend<<<B as Block>::Header as Header>::Hashing>>::Transaction, <<B as Block>::Header as Header>::Hashing>>>,
        execution_manager: ExecutionManager<EM>,
        native_call: Option<NC>,
        proof_recorder: &Option<Recorder<<<B as Block>::Header as Header>::Hashing>>,
        extensions: Option<Extensions>
    ) -> Result<NativeOrEncoded<R>, Error>
    where
        EM: Fn(Result<NativeOrEncoded<R>, Self::Error>, Result<NativeOrEncoded<R>, Self::Error>) -> Result<NativeOrEncoded<R>, Self::Error>,
        R: Encode + Decode + PartialEq<R>,
        NC: FnOnce() -> Result<R, ApiError> + UnwindSafe,
        ExecutionManager<EM>: Clone;
    fn runtime_version(&self, id: &BlockId<B>) -> Result<RuntimeVersion, Error>;
    fn prove_execution(
        &self,
        at: &BlockId<B>,
        method: &str,
        call_data: &[u8]
    ) -> Result<(Vec<u8, Global>, StorageProof), Error>;
}

Method call executor.

Required Associated Types

type Error: Error

Externalities error type.

type Backend: Backend<B>

The backend used by the node.

Required Methods

fn call(
    &self,
    id: &BlockId<B>,
    method: &str,
    call_data: &[u8],
    strategy: ExecutionStrategy,
    extensions: Option<Extensions>
) -> Result<Vec<u8, Global>, Error>

Execute a call to a contract on top of state in a block of given hash.

No changes are made.

fn contextual_call<EM, R, NC>(
    &self,
    at: &BlockId<B>,
    method: &str,
    call_data: &[u8],
    changes: &RefCell<OverlayedChanges>,
    storage_transaction_cache: Option<&RefCell<StorageTransactionCache<<<Self::Backend as Backend<B>>::State as Backend<<<B as Block>::Header as Header>::Hashing>>::Transaction, <<B as Block>::Header as Header>::Hashing>>>,
    execution_manager: ExecutionManager<EM>,
    native_call: Option<NC>,
    proof_recorder: &Option<Recorder<<<B as Block>::Header as Header>::Hashing>>,
    extensions: Option<Extensions>
) -> Result<NativeOrEncoded<R>, Error>where
    EM: Fn(Result<NativeOrEncoded<R>, Self::Error>, Result<NativeOrEncoded<R>, Self::Error>) -> Result<NativeOrEncoded<R>, Self::Error>,
    R: Encode + Decode + PartialEq<R>,
    NC: FnOnce() -> Result<R, ApiError> + UnwindSafe,
    ExecutionManager<EM>: Clone,

Execute a contextual call on top of state in a block of a given hash.

No changes are made. Before executing the method, passed header is installed as the current header of the execution context.

fn runtime_version(&self, id: &BlockId<B>) -> Result<RuntimeVersion, Error>

Extract RuntimeVersion of given block

No changes are made.

fn prove_execution(
    &self,
    at: &BlockId<B>,
    method: &str,
    call_data: &[u8]
) -> Result<(Vec<u8, Global>, StorageProof), Error>

Prove the execution of the given method.

No changes are made.

Implementations on Foreign Types

impl<B, E, Block> CallExecutor<Block> for LocalCallExecutor<Block, B, E>where
    B: Backend<Block>,
    E: 'static + CodeExecutor + RuntimeVersionOf + Clone,
    Block: Block,

type Error = <E as CodeExecutor>::Error

type Backend = B

fn call(
    &self,
    at: &BlockId<Block>,
    method: &str,
    call_data: &[u8],
    strategy: ExecutionStrategy,
    extensions: Option<Extensions>
) -> Result<Vec<u8, Global>, Error>

fn contextual_call<EM, R, NC>(
    &self,
    at: &BlockId<Block>,
    method: &str,
    call_data: &[u8],
    changes: &RefCell<OverlayedChanges>,
    storage_transaction_cache: Option<&RefCell<StorageTransactionCache<<<B as Backend<Block>>::State as Backend<<<Block as Block>::Header as Header>::Hashing>>::Transaction, <<Block as Block>::Header as Header>::Hashing>>>,
    execution_manager: ExecutionManager<EM>,
    native_call: Option<NC>,
    recorder: &Option<Recorder<<<Block as Block>::Header as Header>::Hashing>>,
    extensions: Option<Extensions>
) -> Result<NativeOrEncoded<R>, Error>where
    EM: Fn(Result<NativeOrEncoded<R>, <LocalCallExecutor<Block, B, E> as CallExecutor<Block>>::Error>, Result<NativeOrEncoded<R>, <LocalCallExecutor<Block, B, E> as CallExecutor<Block>>::Error>) -> Result<NativeOrEncoded<R>, <LocalCallExecutor<Block, B, E> as CallExecutor<Block>>::Error>,
    R: Encode + Decode + PartialEq<R>,
    NC: FnOnce() -> Result<R, ApiError> + UnwindSafe,
    ExecutionManager<EM>: Clone,

fn runtime_version(&self, id: &BlockId<Block>) -> Result<RuntimeVersion, Error>

fn prove_execution(
    &self,
    at: &BlockId<Block>,
    method: &str,
    call_data: &[u8]
) -> Result<(Vec<u8, Global>, StorageProof), Error>

Implementors