Struct ChainStateView 

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

    pub execution_state: ExecutionStateView<C>,
    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 block_hashes: CustomMapView<C, BlockHeight, CryptoHash>,
    pub received_log: LogView<C, ChainAndHeight>,
    pub received_certificate_trackers: RegisterView<C, HashMap<ValidatorPublicKey, u64>>,
    pub inboxes: ReentrantCollectionView<C, ChainId, InboxStateView<C>>,
    pub outboxes: ReentrantCollectionView<C, ChainId, OutboxStateView<C>>,
    pub next_expected_events: MapView<C, StreamId, u32>,
    pub outbox_counters: RegisterView<C, NonCanonicalBTreeMap<BlockHeight, u32>>,
    pub nonempty_outboxes: RegisterView<C, NonCanonicalBTreeSet<ChainId>>,
    pub nonempty_inboxes: RegisterView<C, NonCanonicalBTreeSet<ChainId>>,
    pub block_zero_executed_at: RegisterView<C, Timestamp>,
    pub next_height_to_preprocess: RegisterView<C, BlockHeight>,
    pub latest_checkpoint_height: RegisterView<C, Option<BlockHeight>>,
    pub pre_checkpoint_block_trust: SetView<C, CryptoHash>,
    pub outbox_index_tracked_hash: RegisterView<C, Option<CryptoHash>>,
}

A view accessing the state of a chain.

Fields

execution_state: ExecutionStateView<C>

Execution state, including system and user applications.

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.

block_hashes: CustomMapView<C, BlockHeight, CryptoHash>

Hashes of all known blocks in this chain, indexed by their height. A block at height < next_block_height is executed; a block at height >= next_block_height is preprocessed (verified but not yet executed) and may not be contiguous.

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.

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, NonCanonicalBTreeMap<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, NonCanonicalBTreeSet<ChainId>>

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

nonempty_inboxes: RegisterView<C, NonCanonicalBTreeSet<ChainId>>

Inboxes with at least one pending added bundle. This allows us to avoid loading all inboxes.

block_zero_executed_at: RegisterView<C, Timestamp>

The local wall-clock time when block 0 was last executed. Used to prevent reset-on-incorrect-outcome from looping: if not enough time has elapsed since the last reset, the error is returned instead.

next_height_to_preprocess: RegisterView<C, BlockHeight>

The height at which the next block can be preprocessed: one past the highest height in block_hashes (executed or preprocessed), or next_block_height if block_hashes is empty.

Maintained as an O(1) shortcut for next_height_to_preprocess, since CustomMapView does not yet expose a last_index lookup. Once linera-views gains efficient first/last key support, this field can be removed in favor of block_hashes.last_index().

latest_checkpoint_height: RegisterView<C, Option<BlockHeight>>

The height of the most recent checkpoint block applied to this chain, if any. Maintained by apply_confirmed_block whenever a block starting with SystemOperation::Checkpoint is executed.

pre_checkpoint_block_trust: SetView<C, CryptoHash>

Hashes of pre-checkpoint sender blocks the chain has seen a checkpoint cert vouch for via outbox_block_hashes, but whose actual cert bytes are not yet in storage. The worker errors a checkpoint push with MissingPreCheckpointBlocks when this set is non-empty, then accepts each referenced cert (regardless of its own — possibly revoked — epoch) and removes the entry. Once the set is empty, the checkpoint restoration can run end-to-end.

outbox_index_tracked_hash: RegisterView<C, Option<CryptoHash>>

The hash of the set of fully-tracked chains that nonempty_outboxes and outbox_counters were last reconciled against. On a client these two indices only hold entries for tracked targets; when the tracked set changes this hash stops matching and the indices are reconciled (reconcile_outbox_index). None means they have never been filtered — a pre-existing database entry (migration), or a validator that tracks all chains and never filters.

Implementations

impl<C> ChainStateView<C>

where C: Clone + Context + 'static,

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

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 block_hashes( &self, ctx: &Context<'_>, ) -> Result<&CustomMapView<C, BlockHeight, 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 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, NonCanonicalBTreeMap<BlockHeight, u32>>>

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

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

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

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

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

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

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

impl<C> ChainStateView<C>

where C: Context + Clone + '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, tracked: Option<&ChainIdSet>, ) -> 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 async fn is_active(&self) -> Result<bool, ChainError>

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 receive_message_bundle_with_inbox( &mut self, inbox: &mut InboxStateView<C>, 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 async fn current_committee( &self, ) -> Result<(Epoch, Arc<Committee>), ChainError>

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

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 reconcile_outbox_index( &mut self, tracked: Option<&Hashed<ChainIdSet>>, ) -> Result<bool, ChainError>

Reconciles the nonempty_outboxes and outbox_counters indices from the retained outbox queues, rebuilding only when the tracked set changed since the last call (i.e. the stored Self::outbox_index_tracked_hash no longer matches). The per-target outbox queues in outboxes are always kept; only these indices are filtered. Returns whether a rebuild actually happened, so a read-only caller can skip persisting when nothing changed.

pub fn outbox_index_is_reconciled( &self, tracked: Option<&Hashed<ChainIdSet>>, ) -> bool

Returns whether the outbox index is already reconciled to tracked (the stored hash matches), so the read-only network-actions path can read it without a write-lock rebuild.

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>>>, policy: BundleExecutionPolicy, ) -> Result<(ProposedBlock, BlockExecutionOutcome, ResourceTracker, HashSet<ChainId>), ChainError>

Executes a block with a specified policy for handling bundle failures.

This method supports automatic retry with checkpointing when bundles fail:

• For limit errors (block too large, fuel exceeded, etc.): the bundle is discarded so it can be retried in a later block, unless it’s the first transaction (which gets rejected as inherently too large).
• For non-limit errors: the bundle is rejected (triggering bounced messages).
• After max_failures failed bundles, all remaining message bundles are discarded.

The block may be modified to reflect the actual executed transactions.

pub async fn restore_outboxes_from_unfinalized( &mut self, tracked: Option<&Hashed<ChainIdSet>>, ) -> Result<(), ChainError>

Re-populates outboxes, outbox_counters, and nonempty_outboxes from the on-chain unfinalized_message_blocks map after a checkpoint bootstrap. Called once after execution_state.restore_from_content so the freshly-restored chain can pick up cross-chain delivery for pre-checkpoint messages — the off-chain outbox state isn’t part of the certified checkpoint blob, so without this a bootstrapped node would silently stop pushing pending messages forward.

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

Returns the sorted, deduplicated set of block heights referenced by the on-chain unfinalized_message_blocks map (one entry per height even if multiple bundles at that height are still unfinalized). Used both when building the checkpoint oracle response (to resolve heights to hashes via block_hashes) and on the bootstrap path (to zip with the certified outbox_block_hashes from the response).

pub async fn apply_confirmed_block( &mut self, block: &ConfirmedBlock, local_time: Timestamp, tracked: Option<&ChainIdSet>, ) -> 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, tracked: Option<&ChainIdSet>, ) -> Result<BTreeSet<StreamId>, ChainError>

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

pub async fn block_hashes_for_heights( &self, heights: impl IntoIterator<Item = BlockHeight>, ) -> Result<Vec<CryptoHash>, ChainError>

Returns the hashes of all blocks we have at the given heights, in input order. Unknown heights are skipped.

Trait Implementations

impl<C> Allocative for ChainStateView<C>

where C: Clone + Context + 'static,

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

impl<C> ClonableView for ChainStateView<C>

where C: Clone + Context + 'static, ExecutionStateView<C>: ClonableView, RegisterView<C, ChainTipState>: ClonableView, ChainManager<C>: ClonableView, PendingBlobsView<C>: ClonableView, ReentrantCollectionView<C, AccountOwner, PendingBlobsView<C>>: ClonableView, CustomMapView<C, BlockHeight, CryptoHash>: ClonableView, LogView<C, ChainAndHeight>: ClonableView, RegisterView<C, HashMap<ValidatorPublicKey, u64>>: ClonableView, ReentrantCollectionView<C, ChainId, InboxStateView<C>>: ClonableView, ReentrantCollectionView<C, ChainId, OutboxStateView<C>>: ClonableView, MapView<C, StreamId, u32>: ClonableView, RegisterView<C, NonCanonicalBTreeMap<BlockHeight, u32>>: ClonableView, RegisterView<C, NonCanonicalBTreeSet<ChainId>>: ClonableView, RegisterView<C, Timestamp>: ClonableView, RegisterView<C, BlockHeight>: ClonableView, RegisterView<C, Option<BlockHeight>>: ClonableView, SetView<C, CryptoHash>: ClonableView, RegisterView<C, Option<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 + '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 + '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 + '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 + 'static, Self: View,

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

Saves the root view to the database context

async fn save_and_drop(self) -> Result<(), ViewError>

Saves the root view to the database context and then drops it without calling post_save.

impl<C> View for ChainStateView<C>

where C: Context + Clone + Context + 'static, ExecutionStateView<C>: 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>, CustomMapView<C, BlockHeight, 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>, ReentrantCollectionView<C, ChainId, OutboxStateView<C>>: View<Context = C>, MapView<C, StreamId, u32>: View<Context = C>, RegisterView<C, NonCanonicalBTreeMap<BlockHeight, u32>>: View<Context = C>, RegisterView<C, NonCanonicalBTreeSet<ChainId>>: View<Context = C>, RegisterView<C, Timestamp>: View<Context = C>, RegisterView<C, BlockHeight>: View<Context = C>, RegisterView<C, Option<BlockHeight>>: View<Context = C>, SetView<C, CryptoHash>: View<Context = C>, RegisterView<C, Option<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 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> ObjectType for ChainStateView<C>

where C: Clone + Context + 'static,