Struct linera_execution::system::SystemExecutionStateView

pub struct SystemExecutionStateView<C> {
    pub description: RegisterView<C, Option<ChainDescription>>,
    pub epoch: RegisterView<C, Option<Epoch>>,
    pub admin_id: RegisterView<C, Option<ChainId>>,
    pub subscriptions: SetView<C, ChannelSubscription>,
    pub committees: RegisterView<C, BTreeMap<Epoch, Committee>>,
    pub ownership: RegisterView<C, ChainOwnership>,
    pub balance: RegisterView<C, Amount>,
    pub balances: MapView<C, Owner, Amount>,
    pub timestamp: RegisterView<C, Timestamp>,
    pub registry: ApplicationRegistryView<C>,
}

A view accessing the execution state of the system of a chain.

Fields

description: RegisterView<C, Option<ChainDescription>>

How the chain was created. May be unknown for inactive chains.

epoch: RegisterView<C, Option<Epoch>>

The number identifying the current configuration.

admin_id: RegisterView<C, Option<ChainId>>

The admin of the chain.

subscriptions: SetView<C, ChannelSubscription>

Track the channels that we have subscribed to.

committees: RegisterView<C, BTreeMap<Epoch, Committee>>

The committees that we trust, indexed by epoch number. Not using a MapView because the set active of committees is supposed to be small. Plus, currently, we would create the BTreeMap anyway in various places (e.g. the OpenChain operation).

ownership: RegisterView<C, ChainOwnership>

Ownership of the chain.

balance: RegisterView<C, Amount>

Balance of the chain (unattributed).

balances: MapView<C, Owner, Amount>

Balances attributed to a given owner.

timestamp: RegisterView<C, Timestamp>

The timestamp of the most recent block.

registry: ApplicationRegistryView<C>

Track the locations of known bytecodes as well as the descriptions of known applications.

Implementations

impl<C> SystemExecutionStateView<C>where C: Context + Clone + Send + Sync + 'static, ViewError: From<C::Error>,

pub fn is_active(&self) -> bool

Invariant for the states of active chains.

pub fn current_committee(&self) -> Option<(Epoch, &Committee)>

Returns the current committee, if any.

pub async fn execute_operation( &mut self, context: &OperationContext, operation: &SystemOperation ) -> Result<(RawExecutionResult<SystemMessage>, Option<(UserApplicationId, Vec<u8>)>), SystemExecutionError>

Executes the sender’s side of an operation and returns a list of actions to be taken.

pub async fn execute_message( &mut self, context: &MessageContext, message: &SystemMessage ) -> Result<RawExecutionResult<SystemMessage>, SystemExecutionError>

Executes a cross-chain message that represents the recipient’s side of an operation.

• Messages should not return an error unless it is a temporary failure (e.g. storage) or a global system failure. An error will fail the entire cross-chain request, allowing it to be retried later.

• If execution is impossible for a deterministic reason (e.g. insufficient funds), messages should fail silently and be skipped (similar to a transaction in traditional blockchains).

pub fn open_chain( &mut self, message_id: MessageId, ownership: ChainOwnership, epoch: Epoch, committees: BTreeMap<Epoch, Committee>, admin_id: ChainId, timestamp: Timestamp )

Initializes the system application state on a newly opened chain.

pub async fn query_application( &mut self, context: &QueryContext, _query: &SystemQuery ) -> Result<SystemResponse, SystemExecutionError>

Trait Implementations

impl<C: Send + Sync + Context> ContainerType for SystemExecutionStateView<C>where ViewError: From<C::Error>,

fn resolve_field<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 Context<'life2> ) -> Pin<Box<dyn Future<Output = ServerResult<Option<Value>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn find_entity<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 Context<'life2>, params: &'life3 Value ) -> Pin<Box<dyn Future<Output = ServerResult<Option<Value>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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 for SystemExecutionStateView<C>where RegisterView<C, Option<ChainDescription>>: Debug, RegisterView<C, Option<Epoch>>: Debug, RegisterView<C, Option<ChainId>>: Debug, SetView<C, ChannelSubscription>: Debug, RegisterView<C, BTreeMap<Epoch, Committee>>: Debug, RegisterView<C, ChainOwnership>: Debug, RegisterView<C, Amount>: Debug, MapView<C, Owner, Amount>: Debug, RegisterView<C, Timestamp>: Debug, ApplicationRegistryView<C>: Debug,

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

Formats the value using the given formatter.

impl<C> HashableView<C> for SystemExecutionStateView<C>where C: Context + Send + Sync + Clone + 'static, ViewError: From<C::Error>,

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

fn hash_mut<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Computes the hash of the values.

fn hash<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<<Self::Hasher as Hasher>::Output, ViewError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Computes the hash of the values.

impl<C: Send + Sync + Context> OutputType for SystemExecutionStateView<C>where ViewError: From<C::Error>,

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.

fn resolve<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 ContextSelectionSet<'life2>, _field: &'life3 Positioned<Field> ) -> Pin<Box<dyn Future<Output = ServerResult<Value>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

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> View<C> for SystemExecutionStateView<C>where C: Context + Send + Sync + Clone + 'static, ViewError: From<C::Error>,

fn context(&self) -> &C

Obtains a mutable reference to the internal context.

fn load<'async_trait>( context: C ) -> Pin<Box<dyn Future<Output = Result<Self, ViewError>> + Send + 'async_trait>>where Self: 'async_trait,

Creates a view or a subview.

fn rollback(&mut self)

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

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

Persists changes to storage. This leaves the view still usable and is essentially neutral to the program running. Crash-resistant storage implementations are expected to accumulate the desired changes in the batch variable first. If the view is dropped without calling flush, staged changes are simply lost.

fn delete(self, batch: &mut Batch)

Instead of persisting changes, clears all the data that belong to this view and its subviews. Crash-resistant storage implementations are expected to accumulate the desired changes into the batch variable first. No data/metadata at all is left after deletion. The view is consumed by delete.

fn clear(&mut self)

Clears the view. That can be seen as resetting to default. In the case of a RegisterView this means setting the value to T::default(). For LogView, QueueView, this leaves the range data to be left in the database.

impl<C: Send + Sync + Context> ObjectType for SystemExecutionStateView<C>where ViewError: From<C::Error>,