Struct 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 committees: HashedRegisterView<C, BTreeMap<Epoch, Committee>>,
    pub ownership: HashedRegisterView<C, ChainOwnership>,
    pub balance: HashedRegisterView<C, Amount>,
    pub balances: HashedMapView<C, AccountOwner, Amount>,
    pub timestamp: HashedRegisterView<C, Timestamp>,
    pub closed: HashedRegisterView<C, bool>,
    pub application_permissions: HashedRegisterView<C, ApplicationPermissions>,
    pub used_blobs: HashedSetView<C, BlobId>,
    pub event_subscriptions: MapView<C, (ChainId, StreamId), EventSubscriptions>,
}

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.

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

Balances attributed to a given owner.

timestamp: HashedRegisterView<C, Timestamp>

The timestamp of the most recent block.

closed: HashedRegisterView<C, bool>

Whether this chain has been closed.

application_permissions: HashedRegisterView<C, ApplicationPermissions>

Permissions for applications on this chain.

used_blobs: HashedSetView<C, BlobId>

Blobs that have been used or published on this chain.

event_subscriptions: MapView<C, (ChainId, StreamId), EventSubscriptions>

The event stream subscriptions of applications on this chain.

Implementations

impl<C> SystemExecutionStateView<C>

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

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, txn_tracker: &mut TransactionTracker, resource_controller: &mut ResourceController<Option<AccountOwner>>, ) -> Result<Option<(ApplicationId, Vec<u8>)>, ExecutionError>

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<AccountOwner>, authenticated_application_id: Option<ApplicationId>, source: AccountOwner, recipient: Recipient, amount: Amount, ) -> Result<Option<OutgoingMessage>, ExecutionError>

pub async fn claim( &self, authenticated_signer: Option<AccountOwner>, authenticated_application_id: Option<ApplicationId>, source: AccountOwner, target_id: ChainId, recipient: Recipient, amount: Amount, ) -> Result<OutgoingMessage, ExecutionError>

pub async fn execute_message( &mut self, context: MessageContext, message: SystemMessage, ) -> Result<Vec<OutgoingMessage>, ExecutionError>

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<QueryOutcome<SystemResponse>, ExecutionError>

pub async fn open_chain( &mut self, config: OpenChainConfig, next_message_id: MessageId, ) -> Result<OutgoingMessage, ExecutionError>

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) -> Result<(), ExecutionError>

pub async fn create_application( &mut self, chain_id: ChainId, block_height: BlockHeight, module_id: ModuleId, parameters: Vec<u8>, required_application_ids: Vec<ApplicationId>, txn_tracker: TransactionTracker, ) -> Result<CreateApplicationResult, ExecutionError>

pub async fn describe_application( &mut self, id: ApplicationId, txn_tracker: Option<&mut TransactionTracker>, ) -> Result<ApplicationDescription, ExecutionError>

Retrieves an application’s description.

pub async fn find_dependencies( &mut self, stack: Vec<ApplicationId>, txn_tracker: &mut TransactionTracker, ) -> Result<Vec<ApplicationId>, ExecutionError>

Retrieves the recursive dependencies of applications and applies a topological sort.

pub async fn read_blob_content( &self, blob_id: BlobId, ) -> Result<BlobContent, ExecutionError>

pub async fn assert_blob_exists( &mut self, blob_id: BlobId, ) -> Result<(), ExecutionError>

Trait Implementations

impl<C> ClonableView<C> for SystemExecutionStateView<C>

where C: Context + Send + Sync + Clone + 'static,

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

where HashedRegisterView<C, Option<ChainDescription>>: Debug, HashedRegisterView<C, Option<Epoch>>: Debug, HashedRegisterView<C, Option<ChainId>>: Debug, HashedRegisterView<C, BTreeMap<Epoch, Committee>>: Debug, HashedRegisterView<C, ChainOwnership>: Debug, HashedRegisterView<C, Amount>: Debug, HashedMapView<C, AccountOwner, Amount>: Debug, HashedRegisterView<C, Timestamp>: Debug, HashedRegisterView<C, bool>: Debug, HashedRegisterView<C, ApplicationPermissions>: Debug, HashedSetView<C, BlobId>: Debug, MapView<C, (ChainId, StreamId), EventSubscriptions>: 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,

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>

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,

const NUM_INIT_KEYS: usize = 20usize

The number of keys used for the initialization

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

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

where Self: 'async_trait,

Loads a view

fn rollback(&mut self)

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

fn has_pending_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns true if flushing this view would result in changes to the persistent 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.

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

Builds a trivial view that is already deleted

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