Struct ChainStateView

pub struct ChainStateView<C>
where
    C: Clone + Context + Send + Sync + 'static,
{

    pub execution_state: ExecutionStateView<C>,
    pub execution_state_hash: RegisterView<C, Option<CryptoHash>>,
    pub tip_state: RegisterView<C, ChainTipState>,
    pub manager: ChainManager<C>,
    pub pending_validated_blobs: PendingBlobsView<C>,
    pub pending_proposed_blobs: ReentrantCollectionView<C, AccountOwner, PendingBlobsView<C>>,
    pub confirmed_log: LogView<C, CryptoHash>,
    pub received_log: LogView<C, ChainAndHeight>,
    pub received_certificate_trackers: RegisterView<C, HashMap<ValidatorPublicKey, u64>>,
    pub inboxes: ReentrantCollectionView<C, Origin, InboxStateView<C>>,
    pub unskippable_bundles: QueueView<C, TimestampedBundleInInbox>,
    pub removed_unskippable_bundles: SetView<C, BundleInInbox>,
    pub previous_message_blocks: MapView<C, ChainId, BlockHeight>,
    pub outboxes: ReentrantCollectionView<C, Target, OutboxStateView<C>>,
    pub outbox_counters: RegisterView<C, BTreeMap<BlockHeight, u32>>,
    pub channels: ReentrantCollectionView<C, ChannelFullName, ChannelStateView<C>>,
}

A view accessing the state of a chain.

Fields

execution_state: ExecutionStateView<C>

Execution state, including system and user applications.

execution_state_hash: RegisterView<C, Option<CryptoHash>>

Hash of the execution state.

tip_state: RegisterView<C, ChainTipState>

Block-chaining state.

manager: ChainManager<C>

Consensus state.

pending_validated_blobs: PendingBlobsView<C>

Pending validated block that is still missing blobs. The incomplete set of blobs for the pending validated block.

pending_proposed_blobs: ReentrantCollectionView<C, AccountOwner, PendingBlobsView<C>>

The incomplete sets of blobs for upcoming proposals.

confirmed_log: LogView<C, CryptoHash>

Hashes of all certified blocks for this sender. This ends with block_hash and has length usize::from(next_block_height).

received_log: LogView<C, ChainAndHeight>

Sender chain and height of all certified blocks known as a receiver (local ordering).

received_certificate_trackers: RegisterView<C, HashMap<ValidatorPublicKey, u64>>

The number of received_log entries we have synchronized, for each validator.

inboxes: ReentrantCollectionView<C, Origin, InboxStateView<C>>

Mailboxes used to receive messages indexed by their origin.

unskippable_bundles: QueueView<C, TimestampedBundleInInbox>

A queue of unskippable bundles, with the timestamp when we added them to the inbox.

removed_unskippable_bundles: SetView<C, BundleInInbox>

Unskippable bundles that have been removed but are still in the queue.

previous_message_blocks: MapView<C, ChainId, BlockHeight>

The heights of previous blocks that sent messages to the same recipients.

outboxes: ReentrantCollectionView<C, Target, OutboxStateView<C>>

Mailboxes used to send messages, indexed by their target.

outbox_counters: RegisterView<C, BTreeMap<BlockHeight, u32>>

Number of outgoing messages in flight for each block height. We use a RegisterView to prioritize speed for small maps.

channels: ReentrantCollectionView<C, ChannelFullName, ChannelStateView<C>>

Channels able to multicast messages to subscribers.

Implementations

impl<C> ChainStateView<C>

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

pub async fn execution_state( &self, ctx: &Context<'_>, ) -> Result<&ExecutionStateView<C>>

pub async fn execution_state_hash( &self, ctx: &Context<'_>, ) -> Result<&RegisterView<C, Option<CryptoHash>>>

pub async fn tip_state( &self, ctx: &Context<'_>, ) -> Result<&RegisterView<C, ChainTipState>>

pub async fn manager(&self, ctx: &Context<'_>) -> Result<&ChainManager<C>>

pub async fn pending_validated_blobs( &self, ctx: &Context<'_>, ) -> Result<&PendingBlobsView<C>>

pub async fn pending_proposed_blobs( &self, ctx: &Context<'_>, ) -> Result<&ReentrantCollectionView<C, AccountOwner, PendingBlobsView<C>>>

pub async fn confirmed_log( &self, ctx: &Context<'_>, ) -> Result<&LogView<C, CryptoHash>>

pub async fn received_log( &self, ctx: &Context<'_>, ) -> Result<&LogView<C, ChainAndHeight>>

pub async fn received_certificate_trackers( &self, ctx: &Context<'_>, ) -> Result<&RegisterView<C, HashMap<ValidatorPublicKey, u64>>>

pub async fn inboxes( &self, ctx: &Context<'_>, ) -> Result<&ReentrantCollectionView<C, Origin, InboxStateView<C>>>

pub async fn unskippable_bundles( &self, ctx: &Context<'_>, ) -> Result<&QueueView<C, TimestampedBundleInInbox>>

pub async fn removed_unskippable_bundles( &self, ctx: &Context<'_>, ) -> Result<&SetView<C, BundleInInbox>>

pub async fn previous_message_blocks( &self, ctx: &Context<'_>, ) -> Result<&MapView<C, ChainId, BlockHeight>>

pub async fn outboxes( &self, ctx: &Context<'_>, ) -> Result<&ReentrantCollectionView<C, Target, OutboxStateView<C>>>

pub async fn outbox_counters( &self, ctx: &Context<'_>, ) -> Result<&RegisterView<C, BTreeMap<BlockHeight, u32>>>

pub async fn channels( &self, ctx: &Context<'_>, ) -> Result<&ReentrantCollectionView<C, ChannelFullName, ChannelStateView<C>>>

impl<C> ChainStateView<C>

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

pub fn chain_id(&self) -> ChainId

Returns the ChainId of the chain this ChainStateView represents.

pub async fn query_application( &mut self, local_time: Timestamp, query: Query, service_runtime_endpoint: Option<&mut ServiceRuntimeEndpoint>, ) -> Result<QueryOutcome, ChainError>

pub async fn describe_application( &mut self, application_id: ApplicationId, ) -> Result<ApplicationDescription, ChainError>

pub async fn mark_messages_as_received( &mut self, target: &Target, height: BlockHeight, ) -> Result<bool, ChainError>

pub fn all_messages_delivered_up_to(&self, height: BlockHeight) -> bool

Returns true if there are no more outgoing messages in flight up to the given block height.

pub fn is_active(&self) -> bool

Invariant for the states of active chains.

pub fn ensure_is_active(&self) -> Result<(), ChainError>

Invariant for the states of active chains.

pub async fn validate_incoming_bundles(&self) -> Result<(), ChainError>

Verifies that this chain is up-to-date and all the messages executed ahead of time have been properly received by now.

pub async fn next_block_height_to_receive( &self, origin: &Origin, ) -> Result<BlockHeight, ChainError>

pub async fn last_anticipated_block_height( &self, origin: &Origin, ) -> Result<Option<BlockHeight>, ChainError>

pub async fn receive_message_bundle( &mut self, origin: &Origin, bundle: MessageBundle, local_time: Timestamp, add_to_received_log: bool, ) -> Result<(), ChainError>

Attempts to process a new bundle of messages from the given origin. Returns an internal error if the bundle doesn’t appear to be new, based on the sender’s height. The value local_time is specific to each validator and only used for round timeouts.

Returns true if incoming Subscribe messages created new outbox entries.

pub fn update_received_certificate_trackers( &mut self, new_trackers: BTreeMap<ValidatorPublicKey, u64>, )

Updates the received_log trackers.

pub async fn execute_init_message_from( &mut self, block: &Block, local_time: Timestamp, ) -> Result<(), ChainError>

Verifies that the block’s first message is OpenChain. Initializes the chain if necessary.

pub fn current_committee(&self) -> Result<(Epoch, &Committee), ChainError>

pub fn ownership(&self) -> &ChainOwnership

pub async fn remove_bundles_from_inboxes( &mut self, timestamp: Timestamp, incoming_bundles: &[IncomingBundle], ) -> Result<(), ChainError>

Removes the incoming message bundles in the block from the inboxes.

pub async fn execute_block_inner( chain: &mut ExecutionStateView<C>, confirmed_log: &LogView<C, CryptoHash>, previous_message_blocks_view: &MapView<C, ChainId, BlockHeight>, block: &ProposedBlock, local_time: Timestamp, round: Option<u32>, published_blobs: &[Blob], replaying_oracle_responses: Option<Vec<Vec<OracleResponse>>>, ) -> Result<(BlockExecutionOutcome, Vec<(ChannelFullName, ChainId)>, Vec<(ChannelFullName, ChainId)>), ChainError>

Executes a block: first the incoming messages, then the main operation. Does not update chain state other than the execution state.

pub async fn execute_block( &mut self, block: &ProposedBlock, local_time: Timestamp, round: Option<u32>, published_blobs: &[Blob], replaying_oracle_responses: Option<Vec<Vec<OracleResponse>>>, ) -> Result<(BlockExecutionOutcome, Vec<(ChannelFullName, ChainId)>, Vec<(ChannelFullName, ChainId)>), ChainError>

Executes a block: first the incoming messages, then the main operation. Does not update chain state other than the execution state.

pub async fn apply_confirmed_block( &mut self, block: &ConfirmedBlock, local_time: Timestamp, ) -> Result<(), ChainError>

Applies an execution outcome to the chain, updating the outboxes, state hash and chain manager. This does not touch the execution state itself, which must be updated separately.

pub fn is_child(&self) -> bool

Returns whether this is a child chain.

pub async fn process_subscribes( &mut self, names_and_ids: Vec<(ChannelFullName, ChainId)>, ) -> Result<bool, ChainError>

Processes new subscriptions. Returns true if at least one new subscriber was added for which we have outgoing messages.

pub async fn process_unsubscribes( &mut self, names_and_ids: Vec<(ChannelFullName, ChainId)>, ) -> Result<(), ChainError>

Trait Implementations

impl<C> ClonableView<C> for ChainStateView<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> ContainerType for ChainStateView<C>

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

async fn resolve_field(&self, ctx: &Context<'_>) -> ServerResult<Option<Value>>

Resolves a field value and outputs it as a json value async_graphql::Value.

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.

fn find_entity( &self, _: &ContextBase<'_, &Positioned<Field>>, _params: &ConstValue, ) -> impl Future<Output = Result<Option<ConstValue>, ServerError>> + Send

Find the GraphQL entity with the given name from the parameter.

impl<C> Debug for ChainStateView<C>

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

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

Formats the value using the given formatter.

impl<C> OutputType for ChainStateView<C>

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

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> RootView<C> for ChainStateView<C>

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

fn save<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), ViewError>> + Send + 'async_trait>>

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

Saves the root view to the database context

impl<C> View<C> for ChainStateView<C>

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

const NUM_INIT_KEYS: usize = 44usize

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> ObjectType for ChainStateView<C>

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