Struct linera_execution::system::SystemExecutionStateView

pub struct SystemExecutionStateView<C> {
    pub description: HashedRegisterView<C, Option<ChainDescription>>,
    pub epoch: HashedRegisterView<C, Option<Epoch>>,
    pub admin_id: HashedRegisterView<C, Option<ChainId>>,
    pub subscriptions: HashedSetView<C, ChannelSubscription>,
    pub committees: HashedRegisterView<C, BTreeMap<Epoch, Committee>>,
    pub ownership: HashedRegisterView<C, ChainOwnership>,
    pub balance: HashedRegisterView<C, Amount>,
    pub balances: HashedMapView<C, Owner, Amount>,
    pub timestamp: HashedRegisterView<C, Timestamp>,
    pub registry: ApplicationRegistryView<C>,
    pub closed: HashedRegisterView<C, bool>,
    pub application_permissions: HashedRegisterView<C, ApplicationPermissions>,
}

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

Fields

description: HashedRegisterView<C, Option<ChainDescription>>

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

epoch: HashedRegisterView<C, Option<Epoch>>

The number identifying the current configuration.

admin_id: HashedRegisterView<C, Option<ChainId>>

The admin of the chain.

subscriptions: HashedSetView<C, ChannelSubscription>

Track the channels that we have subscribed to.

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

The committees that we trust, indexed by epoch number.

ownership: HashedRegisterView<C, ChainOwnership>

Ownership of the chain.

balance: HashedRegisterView<C, Amount>

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

balances: HashedMapView<C, Owner, Amount>

Balances attributed to a given owner.

timestamp: HashedRegisterView<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.

closed: HashedRegisterView<C, bool>

Whether this chain has been closed.

application_permissions: HashedRegisterView<C, ApplicationPermissions>

Permissions for applications on this chain.

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, Amount>, 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 transfer( &mut self, authenticated_signer: Option<Owner>, owner: Option<Owner>, recipient: Recipient, amount: Amount ) -> Result<Option<RawOutgoingMessage<SystemMessage, Amount>>, SystemExecutionError>

pub async fn claim( &self, authenticated_signer: Option<Owner>, owner: Owner, target_id: ChainId, recipient: Recipient, amount: Amount, user_data: UserData ) -> Result<RawOutgoingMessage<SystemMessage, Amount>, SystemExecutionError>

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

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

pub fn initialize_chain( &mut self, message_id: MessageId, timestamp: Timestamp, config: OpenChainConfig )

Initializes the system application state on a newly opened chain.

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

pub fn open_chain( &mut self, config: OpenChainConfig, next_message_id: MessageId ) -> Result<[RawOutgoingMessage<SystemMessage, Amount>; 2], SystemExecutionError>

Returns the messages to open a new chain, and subtracts the new chain’s balance from this chain’s.

pub async fn close_chain( &mut self, id: ChainId ) -> Result<Vec<RawOutgoingMessage<SystemMessage, Amount>>, SystemExecutionError>

Trait Implementations

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

where ViewError: From<C::Error>,

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 for SystemExecutionStateView<C>

where HashedRegisterView<C, Option<ChainDescription>>: Debug, HashedRegisterView<C, Option<Epoch>>: Debug, HashedRegisterView<C, Option<ChainId>>: Debug, HashedSetView<C, ChannelSubscription>: Debug, HashedRegisterView<C, BTreeMap<Epoch, Committee>>: Debug, HashedRegisterView<C, ChainOwnership>: Debug, HashedRegisterView<C, Amount>: Debug, HashedMapView<C, Owner, Amount>: Debug, HashedRegisterView<C, Timestamp>: Debug, ApplicationRegistryView<C>: Debug, HashedRegisterView<C, bool>: Debug, HashedRegisterView<C, ApplicationPermissions>: Debug,

fn fmt(&self, fmt: &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.

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> 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<bool, 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. The returned boolean indicates whether the operation removes the view or not.

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>,