Struct ExecutionStateView 

pub struct ExecutionStateView<C> {
    pub system: SystemExecutionStateView<C>,
    pub users: HashedReentrantCollectionView<C, ApplicationId, KeyValueStoreView<C>>,
    pub stream_event_counts: MapView<C, StreamId, u32>,
    pub historical_hash: RegisterView<C, Option<HasherOutput>>,
}

A view accessing the execution state of a chain.

Fields

system: SystemExecutionStateView<C>

System application.

users: HashedReentrantCollectionView<C, ApplicationId, KeyValueStoreView<C>>

User applications.

stream_event_counts: MapView<C, StreamId, u32>

The number of events in the streams that this chain is writing to.

historical_hash: RegisterView<C, Option<HasherOutput>>

Rolling historical hash of the execution state, used when FLAG_HISTORICAL_HASH (or its shadow variant) is active. None until the first block after activation, which seeds it from the full content hash (via HashableView); subsequent blocks extend it cheaply from the batch that block persists. Appended last so that existing chains load it as None without moving the storage keys of the other fields, and deliberately excluded from the hand-written HashableView impl below (so it never hashes itself).

Implementations

impl<C> ExecutionStateView<C>

where C: Context + Clone + 'static, C::Extra: ExecutionRuntimeContext,

pub async fn crypto_hash_mut(&mut self) -> Result<CryptoHash, ViewError>

Computes the cryptographic hash of the execution state.

impl<C> ExecutionStateView<C>

where C: Context + Clone + 'static, C::Extra: ExecutionRuntimeContext,

pub async fn query_application( &mut self, context: QueryContext, query: Query, endpoint: Option<&mut ServiceRuntimeEndpoint>, ) -> Result<QueryOutcome, ExecutionError>

Runs a query against the given application and returns its response.

pub async fn list_applications( &self, ) -> Result<Vec<(ApplicationId, ApplicationDescription)>, ExecutionError>

Returns the descriptions of all applications registered on this chain.

Trait Implementations

impl<C> Allocative for ExecutionStateView<C>

fn visit<'allocative_a, 'allocative_b: 'allocative_a>( &self, visitor: &'allocative_a mut Visitor<'allocative_b>, )

impl<C> ClonableView for ExecutionStateView<C>

where SystemExecutionStateView<C>: ClonableView, HashedReentrantCollectionView<C, ApplicationId, KeyValueStoreView<C>>: ClonableView, MapView<C, StreamId, u32>: ClonableView, RegisterView<C, Option<HasherOutput>>: ClonableView, Self: View,

fn clone_unchecked(&mut self) -> Result<Self, ViewError>

Creates a clone of this view, sharing the underlying storage context but prone to data races which can corrupt the view state.

impl<C: Send + Sync + Context> ContainerType for ExecutionStateView<C>

async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>

Resolves a field value and outputs it as a json value async_graphql::Value.

async fn find_entity( &self, ctx: &Context<'_>, params: &Value, ) -> ServerResult<Option<Value>>

Find the GraphQL entity with the given name from the parameter.

fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>

where Self: Send + Sync,

Collect all the fields of the container that are queried in the selection set.

impl<C: Debug> Debug for ExecutionStateView<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> HashableView for ExecutionStateView<C>

where C: Context + Clone + 'static, C::Extra: ExecutionRuntimeContext,

Hashes only the content fields of ExecutionStateView, mirroring the HashableView derive but omitting the appended historical_hash register. Keeping this by hand means the rolling hash never feeds back into the content hash that seeds it.

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

async fn hash_mut(&mut self) -> Result<HasherOutput, ViewError>

Same as hash but guaranteed to be wait-free.

async fn hash(&self) -> Result<HasherOutput, ViewError>

Computes the hash of the values.

impl<C: Send + Sync + Context> ObjectType for ExecutionStateView<C>

impl<C: Send + Sync + Context> OutputType for ExecutionStateView<C>

fn type_name() -> Cow<'static, str>

Type the name.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

async fn resolve( &self, ctx: &ContextSelectionSet<'_>, _field: &Positioned<Field>, ) -> ServerResult<Value>

Resolve an output value to async_graphql::Value.

fn qualified_type_name() -> String

Qualified typename.

fn introspection_type_name(&self) -> Cow<'static, str>

Introspection type name

impl<C: Context, C2: Context> ReplaceContext<C2> for ExecutionStateView<C>

type Target = ExecutionStateView<C2>

The type returned after replacing the context.

async fn with_context( &mut self, ctx: impl FnOnce(&Self::Context) -> C2 + Clone, ) -> Self::Target

Returns a view with a replaced context.

impl<C> View for ExecutionStateView<C>

where C: Context, SystemExecutionStateView<C>: View<Context = C>, HashedReentrantCollectionView<C, ApplicationId, KeyValueStoreView<C>>: View<Context = C>, MapView<C, StreamId, u32>: View<Context = C>, RegisterView<C, Option<HasherOutput>>: View<Context = C>,

const NUM_INIT_KEYS: usize

The number of keys used for the initialization

type Context = C

The type of context stored in this view

fn context(&self) -> &C

Obtains a mutable reference to the internal context.

fn pre_load(context: &C) -> Result<Vec<Vec<u8>>, ViewError>

Creates the keys needed for loading the view

fn post_load(context: C, values: &[Option<Vec<u8>>]) -> Result<Self, ViewError>

Loads a view from the values

async fn load(context: C) -> Result<Self, ViewError>

Loads a view

fn rollback(&mut self)

Discards all pending changes. After that flush should have no effect to storage.

async fn has_pending_changes(&self) -> bool

Returns true if flushing this view would result in changes to the persistent storage.

fn pre_save(&self, batch: &mut Batch) -> Result<bool, ViewError>

Computes the batch of operations to persist changes to storage without modifying the view. Crash-resistant storage implementations accumulate the desired changes in the batch variable. The returned boolean indicates whether the operation removes the view or not.

fn post_save(&mut self)

Updates the view state after the batch has been executed in the database. This should be called after pre_save and after the batch has been successfully written to storage. This leaves the view in a clean state with no pending changes.

fn clear(&mut self)

Clears the view. That can be seen as resetting to default. If the clear is followed by a flush then all the relevant data is removed on the storage.

fn new(context: Self::Context) -> Result<Self, ViewError>

Builds a trivial view that is already deleted