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, ChainId, InboxStateView<C>>,
    pub unskippable_bundles: BucketQueueView<C, TimestampedBundleInInbox, TIMESTAMPBUNDLE_BUCKET_SIZE>,
    pub removed_unskippable_bundles: SetView<C, BundleInInbox>,
    pub previous_message_blocks: MapView<C, ChainId, BlockHeight>,
    pub previous_event_blocks: MapView<C, StreamId, BlockHeight>,
    pub outboxes: ReentrantCollectionView<C, ChainId, OutboxStateView<C>>,
    pub next_expected_events: MapView<C, StreamId, u32>,
    pub outbox_counters: RegisterView<C, BTreeMap<BlockHeight, u32>>,
    pub nonempty_outboxes: RegisterView<C, BTreeSet<ChainId>>,
    pub preprocessed_blocks: MapView<C, BlockHeight, CryptoHash>,
}

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, ChainId, InboxStateView<C>>

Mailboxes used to receive messages indexed by their origin.

unskippable_bundles: BucketQueueView<C, TimestampedBundleInInbox, TIMESTAMPBUNDLE_BUCKET_SIZE>

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.

previous_event_blocks: MapView<C, StreamId, BlockHeight>

The heights of previous blocks that published events to the same streams.

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

Mailboxes used to send messages, indexed by their target.

next_expected_events: MapView<C, StreamId, u32>

The indices of next events we expect to see per stream (could be ahead of the last executed block in sparse chains).

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.

nonempty_outboxes: RegisterView<C, BTreeSet<ChainId>>

Outboxes with at least one pending message. This allows us to avoid loading all outboxes.

preprocessed_blocks: MapView<C, BlockHeight, CryptoHash>

Blocks that have been verified but not executed yet, and that may not be contiguous.

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, ChainId, InboxStateView<C>>>

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

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 previous_event_blocks( &self, ctx: &Context<'_>, ) -> Result<&MapView<C, StreamId, BlockHeight>>

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

pub async fn next_expected_events( &self, ctx: &Context<'_>, ) -> Result<&MapView<C, StreamId, u32>>

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

pub async fn nonempty_outboxes( &self, ctx: &Context<'_>, ) -> Result<&RegisterView<C, BTreeSet<ChainId>>>

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

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: &ChainId, 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 async fn initialize_if_needed( &mut self, local_time: Timestamp, ) -> Result<(), ChainError>

Initializes the chain if it is not active yet.

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

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

Returns the height of the highest block we have, plus one. Includes preprocessed blocks.

The “+ 1” is so that it can be used in the same places as next_block_height.

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

pub async fn receive_message_bundle( &mut self, origin: &ChainId, 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 fn current_committee(&self) -> Result<(Epoch, &Committee), ChainError>

pub fn ownership(&self) -> &ChainOwnership

pub async fn remove_bundles_from_inboxes( &mut self, timestamp: Timestamp, must_be_present: bool, incoming_bundles: impl IntoIterator<Item = &IncomingBundle>, ) -> Result<(), ChainError>

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

If must_be_present is true, an error is returned if any of the bundles have not been added to the inbox yet. So this should be true if the bundles are in a block proposal, and false if the block is already confirmed.

pub fn nonempty_outbox_chain_ids(&self) -> Vec<ChainId>

Returns the chain IDs of all recipients for which a message is waiting in the outbox.

pub async fn load_outboxes( &self, targets: &[ChainId], ) -> Result<Vec<ReadGuardedView<OutboxStateView<C>>>, ChainError>

Returns the outboxes for the given targets, or an error if any of them are missing.

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, 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<BTreeSet<StreamId>, 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. Returns the set of event streams that were updated as a result of applying the block.

pub async fn preprocess_block( &mut self, block: &ConfirmedBlock, ) -> Result<BTreeSet<StreamId>, ChainError>

Adds a block to preprocessed_blocks, and updates the outboxes where possible. Returns the set of streams that were updated as a result of preprocessing the block.

pub fn is_child(&self) -> bool

Returns whether this is a child chain.

pub async fn block_hashes( &self, range: impl RangeBounds<BlockHeight>, ) -> Result<Vec<CryptoHash>, ChainError>

Returns the hashes of all blocks we have in the given range.

Trait Implementations

impl<C> ClonableView for ChainStateView<C>

where C: Clone + Context + Send + Sync + 'static, ExecutionStateView<C>: ClonableView, RegisterView<C, Option<CryptoHash>>: ClonableView, RegisterView<C, ChainTipState>: ClonableView, ChainManager<C>: ClonableView, PendingBlobsView<C>: ClonableView, ReentrantCollectionView<C, AccountOwner, PendingBlobsView<C>>: ClonableView, LogView<C, CryptoHash>: ClonableView, LogView<C, ChainAndHeight>: ClonableView, RegisterView<C, HashMap<ValidatorPublicKey, u64>>: ClonableView, ReentrantCollectionView<C, ChainId, InboxStateView<C>>: ClonableView, BucketQueueView<C, TimestampedBundleInInbox, TIMESTAMPBUNDLE_BUCKET_SIZE>: ClonableView, SetView<C, BundleInInbox>: ClonableView, MapView<C, ChainId, BlockHeight>: ClonableView, MapView<C, StreamId, BlockHeight>: ClonableView, ReentrantCollectionView<C, ChainId, OutboxStateView<C>>: ClonableView, MapView<C, StreamId, u32>: ClonableView, RegisterView<C, BTreeMap<BlockHeight, u32>>: ClonableView, RegisterView<C, BTreeSet<ChainId>>: ClonableView, MapView<C, BlockHeight, CryptoHash>: 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> 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 for ChainStateView<C>

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

async fn save(&mut self) -> Result<(), ViewError>

Saves the root view to the database context

impl<C> View for ChainStateView<C>

where C: Context + Clone + Context + Send + Sync + 'static, ExecutionStateView<C>: View<Context = C>, RegisterView<C, Option<CryptoHash>>: View<Context = C>, RegisterView<C, ChainTipState>: View<Context = C>, ChainManager<C>: View<Context = C>, PendingBlobsView<C>: View<Context = C>, ReentrantCollectionView<C, AccountOwner, PendingBlobsView<C>>: View<Context = C>, LogView<C, CryptoHash>: View<Context = C>, LogView<C, ChainAndHeight>: View<Context = C>, RegisterView<C, HashMap<ValidatorPublicKey, u64>>: View<Context = C>, ReentrantCollectionView<C, ChainId, InboxStateView<C>>: View<Context = C>, BucketQueueView<C, TimestampedBundleInInbox, TIMESTAMPBUNDLE_BUCKET_SIZE>: View<Context = C>, SetView<C, BundleInInbox>: View<Context = C>, MapView<C, ChainId, BlockHeight>: View<Context = C>, MapView<C, StreamId, BlockHeight>: View<Context = C>, ReentrantCollectionView<C, ChainId, OutboxStateView<C>>: View<Context = C>, MapView<C, StreamId, u32>: View<Context = C>, RegisterView<C, BTreeMap<BlockHeight, u32>>: View<Context = C>, RegisterView<C, BTreeSet<ChainId>>: View<Context = C>, MapView<C, BlockHeight, CryptoHash>: 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 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: Self::Context) -> Result<Self, ViewError>

Builds a trivial view that is already deleted

impl<C> ObjectType for ChainStateView<C>

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