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.

ownership: RegisterView<C, ChainOwnership>

Ownership of the chain.

balance: RegisterView<C, Amount>

Balance of the chain. (Available to any user able to create blocks in the chain.)

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<(RawExecutionOutcome<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<RawExecutionOutcome<SystemMessage>, SystemExecutionError>

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

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

Initializes the system application state on a newly opened chain.

pub async fn handle_query( &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 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.

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

where ViewError: From<C::Error>,