Struct SystemExecutionStateView

pub struct SystemExecutionStateView<C> {

    pub description: RegisterView<C, Option<ChainDescription>>,
    pub epoch: RegisterView<C, Epoch>,
    pub admin_id: RegisterView<C, Option<ChainId>>,
    pub committees: RegisterView<C, BTreeMap<Epoch, Committee>>,
    pub ownership: RegisterView<C, ChainOwnership>,
    pub balance: RegisterView<C, Amount>,
    pub balances: MapView<C, AccountOwner, Amount>,
    pub timestamp: RegisterView<C, Timestamp>,
    pub closed: RegisterView<C, bool>,
    pub application_permissions: RegisterView<C, ApplicationPermissions>,
    pub used_blobs: SetView<C, BlobId>,
    pub event_subscriptions: MapView<C, (ChainId, StreamId), EventSubscriptions>,
    pub stream_event_counts: MapView<C, StreamId, u32>,
}

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

The number identifying the current configuration.

admin_id: RegisterView<C, Option<ChainId>>

The admin of the chain.

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

Balances attributed to a given owner.

timestamp: RegisterView<C, Timestamp>

The timestamp of the most recent block.

closed: RegisterView<C, bool>

Whether this chain has been closed.

application_permissions: RegisterView<C, ApplicationPermissions>

Permissions for applications on this chain.

used_blobs: SetView<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.

stream_event_counts: MapView<C, StreamId, u32>

The number of events in the streams that this chain is writing to.

Implementations

impl<C> SystemExecutionStateView<C>

where C: Context + Clone + '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_owner: Option<AccountOwner>, authenticated_application_id: Option<ApplicationId>, source: AccountOwner, recipient: Account, amount: Amount, ) -> Result<Option<OutgoingMessage>, ExecutionError>

pub async fn claim( &mut self, authenticated_owner: 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, ) -> QueryOutcome<SystemResponse>

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)

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 RegisterView<C, Option<ChainDescription>>: ClonableView, RegisterView<C, Epoch>: ClonableView, RegisterView<C, Option<ChainId>>: ClonableView, RegisterView<C, BTreeMap<Epoch, Committee>>: ClonableView, RegisterView<C, ChainOwnership>: ClonableView, RegisterView<C, Amount>: ClonableView, MapView<C, AccountOwner, Amount>: ClonableView, RegisterView<C, Timestamp>: ClonableView, RegisterView<C, bool>: ClonableView, RegisterView<C, ApplicationPermissions>: ClonableView, SetView<C, BlobId>: ClonableView, MapView<C, (ChainId, StreamId), EventSubscriptions>: ClonableView, MapView<C, StreamId, u32>: 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 RegisterView<C, Option<ChainDescription>>: Debug, RegisterView<C, Epoch>: Debug, RegisterView<C, Option<ChainId>>: Debug, RegisterView<C, BTreeMap<Epoch, Committee>>: Debug, RegisterView<C, ChainOwnership>: Debug, RegisterView<C, Amount>: Debug, MapView<C, AccountOwner, Amount>: Debug, RegisterView<C, Timestamp>: Debug, RegisterView<C, bool>: Debug, RegisterView<C, ApplicationPermissions>: Debug, SetView<C, BlobId>: Debug, MapView<C, (ChainId, StreamId), EventSubscriptions>: Debug, MapView<C, StreamId, u32>: Debug,

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

Formats the value using the given formatter.

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

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

fn creator_chain_id(&self) -> ChainId

Returns the chain to use for the creation of the application.

async fn register_mock_application_with( &mut self, description: ApplicationDescription, contract: Blob, service: Blob, ) -> Result<(ApplicationId, MockApplication)>

Registers a new MockApplication associated with a ApplicationDescription and its bytecode Blobs.

async fn register_mock_application( &mut self, index: u32, ) -> Result<(ApplicationId, MockApplication, [BlobId; 3])>

Registers a new MockApplication and returns it with the ApplicationId that was used for it.

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, RegisterView<C, Option<ChainDescription>>: View<Context = C>, RegisterView<C, Epoch>: View<Context = C>, RegisterView<C, Option<ChainId>>: View<Context = C>, RegisterView<C, BTreeMap<Epoch, Committee>>: View<Context = C>, RegisterView<C, ChainOwnership>: View<Context = C>, RegisterView<C, Amount>: View<Context = C>, MapView<C, AccountOwner, Amount>: View<Context = C>, RegisterView<C, Timestamp>: View<Context = C>, RegisterView<C, bool>: View<Context = C>, RegisterView<C, ApplicationPermissions>: View<Context = C>, SetView<C, BlobId>: View<Context = C>, MapView<C, (ChainId, StreamId), EventSubscriptions>: View<Context = C>, MapView<C, StreamId, u32>: 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>