Struct Executor 

pub struct Executor<R = Runtime, S: StateStorage = Storage> {
    pub state_store: StateStore<S>,
    /* private fields */
}

Consumers of the executor are required to poll for new changes in order to be notified of changes or can alternatively use the notification channel.

The type parameters are:

• R: The runtime type (default: Runtime for production, MockRuntime for testing)
• S: The state storage type (default: Storage for disk-based, can use MockStateStorage for in-memory)

Fields

state_store: StateStore<S>

Implementations

impl Executor<MockRuntime, Storage>

Executor with MockRuntime using disk-based state storage (for backward compatibility)

pub async fn new_mock( identifier: &str, op_sender: Option<Sender<(Transaction, Sender<Result<OpEnum, OpRequestError>>)>>, op_manager: Option<Arc<OpManager>>, ) -> Result<Self>

Create a mock executor with disk-based state storage.

Contract code is stored in memory (InMemoryContractStore) for determinism, but state is stored on disk (SQLite). For fully in-memory storage, use new_mock_in_memory.

impl Executor<MockRuntime, MockStateStorage>

Executor with MockRuntime using fully in-memory storage (for deterministic simulation)

pub async fn new_mock_in_memory( _identifier: &str, shared_storage: MockStateStorage, op_sender: Option<Sender<(Transaction, Sender<Result<OpEnum, OpRequestError>>)>>, op_manager: Option<Arc<OpManager>>, ) -> Result<Self>

Create a mock executor with fully in-memory storage.

This is designed for deterministic simulation testing where:

• Both contract code and state are stored in memory
• No disk I/O or background threads (file watchers, compaction)
• State persists across node crash/restart (same MockStateStorage instance)
• State can be inspected/verified through MockStateStorage methods

Arguments

• _identifier - Unused (kept for API compatibility)
• shared_storage - A MockStateStorage instance (clone it to share across restarts)
• op_sender - Optional channel for network operations
• op_manager - Optional reference to the operation manager

impl<S> Executor<MockRuntime, S>

where S: StateStorage + Send + Sync + 'static, <S as StateStorage>::Error: Into<Error>,

Common methods for MockRuntime executors (works with any storage type)

pub async fn handle_request( &mut self, _id: ClientId, _req: ClientRequest<'_>, _updates: Option<Sender<Result<HostResponse, WsClientError>>>, ) -> Result<HostResponse, ExecutorError>

impl Executor<MockWasmRuntime, MockStateStorage>

pub async fn new_mock_wasm( _identifier: &str, shared_storage: MockStateStorage, contract_store: Option<InMemoryContractStore>, op_sender: Option<Sender<(Transaction, Sender<Result<OpEnum, OpRequestError>>)>>, op_manager: Option<Arc<OpManager>>, ) -> Result<Self>

impl Executor<Runtime>

pub async fn from_config_local(config: Arc<Config>) -> Result<Self>

Create an Executor for local-only mode (no network operations). Use this from the binary for local mode execution.

pub async fn preload( &mut self, cli_id: ClientId, contract: ContractContainer, state: WrappedState, related_contracts: RelatedContracts<'static>, )

pub async fn handle_request( &mut self, id: ClientId, req: ClientRequest<'_>, updates: Option<Sender<Result<HostResponse, WsClientError>>>, ) -> Result<HostResponse, ExecutorError>

pub async fn contract_requests( &mut self, req: ContractRequest<'_>, cli_id: ClientId, updates: Option<Sender<Result<HostResponse, WsClientError>>>, ) -> Result<HostResponse, ExecutorError>

Respond to requests made through any API’s from client applications in local mode.

pub fn delegate_request( &mut self, req: DelegateRequest<'_>, origin_contract: Option<&ContractInstanceId>, caller_delegate: Option<&DelegateKey>, ) -> Result<HostResponse, ExecutorError>

impl<R, S> Executor<R, S>

where S: StateStorage + Send + 'static, <S as StateStorage>::Error: Into<Error>,

pub fn test_data_dir(identifier: &str) -> PathBuf

pub fn get_subscription_info(&self) -> Vec<SubscriptionInfo>