Struct SystemExecutionStateView 

pub struct SystemExecutionStateView<C> {
    pub description: HashedLazyRegisterView<C, Option<ChainDescription>>,
    pub epoch: HashedRegisterView<C, Epoch>,
    pub admin_chain_id: HashedRegisterView<C, Option<ChainId>>,
    pub committees: HashedLazyRegisterView<C, BTreeMap<Epoch, Committee>>,
    pub ownership: HashedLazyRegisterView<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: HashedLazyRegisterView<C, ApplicationPermissions>,
    pub used_blobs: HashedSetView<C, BlobId>,
    pub event_subscriptions: HashedMapView<C, (ChainId, StreamId), EventSubscriptions>,
}

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

Fields

description: HashedLazyRegisterView<C, Option<ChainDescription>>

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

epoch: HashedRegisterView<C, Epoch>

The number identifying the current configuration.

admin_chain_id: HashedRegisterView<C, Option<ChainId>>

The admin of the chain.

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

The committees that we trust, indexed by epoch number.

ownership: HashedLazyRegisterView<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: HashedLazyRegisterView<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: HashedMapView<C, (ChainId, StreamId), EventSubscriptions>

The event stream subscriptions of applications on this chain.

Implementations

impl<C> SystemExecutionStateView<C>

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

pub async fn is_active(&self) -> Result<bool, ViewError>

Invariant for the states of active chains.

pub async fn current_committee( &self, ) -> Result<Option<(Epoch, Arc<Committee>)>, ViewError>

Returns the chain’s current epoch together with its committee.

Serves lookups from the process-global crate::SharedCommittees cache, falling back to the NewCommittee event on the admin chain (or the genesis committee blob for epoch 0). If neither source has the committee — which happens when a CreateCommittee/ProcessNewEpoch op earlier in the current block created it, but the block hasn’t been saved yet so the NewCommittee event isn’t persisted (and we deliberately don’t populate the shared cache from an unconfirmed block) — fall back to reading the chain’s own committees view, where the new committee sits as a pending update.

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: Account, amount: Amount, ) -> Result<Option<OutgoingMessage>, ExecutionError>

pub async fn claim( &mut self, authenticated_signer: Option<AccountOwner>, authenticated_application_id: Option<ApplicationId>, source: AccountOwner, target_id: ChainId, recipient: Account, amount: Amount, ) -> Result<Option<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 async fn initialize_chain( &mut self, chain_id: ChainId, ) -> Result<bool, ExecutionError>

Initializes the system application state on a newly opened chain. Returns Ok(true) if the chain was already initialized, Ok(false) if it wasn’t.

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

pub async fn open_chain( &mut self, config: OpenChainConfig, parent: ChainId, block_height: BlockHeight, timestamp: Timestamp, txn_tracker: &mut TransactionTracker, ) -> Result<ChainId, ExecutionError>

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

pub 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: &mut TransactionTracker, ) -> Result<CreateApplicationResult, ExecutionError>

pub async fn describe_application( &mut self, id: ApplicationId, txn_tracker: &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> Allocative for SystemExecutionStateView<C>

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

impl<C> ClonableView for SystemExecutionStateView<C>

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

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

Formats the value using the given formatter.

impl<C> HashableView for SystemExecutionStateView<C>

where HashedLazyRegisterView<C, Option<ChainDescription>>: HashableView, HashedRegisterView<C, Epoch>: HashableView, HashedRegisterView<C, Option<ChainId>>: HashableView, HashedLazyRegisterView<C, BTreeMap<Epoch, Committee>>: HashableView, HashedLazyRegisterView<C, ChainOwnership>: HashableView, HashedRegisterView<C, Amount>: HashableView, HashedMapView<C, AccountOwner, Amount>: HashableView, HashedRegisterView<C, Timestamp>: HashableView, HashedRegisterView<C, bool>: HashableView, HashedLazyRegisterView<C, ApplicationPermissions>: HashableView, HashedSetView<C, BlobId>: HashableView, HashedMapView<C, (ChainId, StreamId), EventSubscriptions>: HashableView, Self: View,

type Hasher = CoreWrapper<Sha3_256Core>

How to compute hashes.

async fn hash_mut( &mut self, ) -> Result<<Self::Hasher as Hasher>::Output, ViewError>

Same as hash but guaranteed to be wait-free.

async fn hash(&self) -> Result<<Self::Hasher as Hasher>::Output, ViewError>

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: Context, C2: Context> ReplaceContext<C2> for SystemExecutionStateView<C>

type Target = SystemExecutionStateView<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 SystemExecutionStateView<C>

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

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