Struct linera_chain::manager::ChainManager

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

    pub ownership: RegisterView<C, ChainOwnership>,
    pub seed: RegisterView<C, u64>,
    pub distribution: RegisterView<C, Option<WeightedAliasIndex<u64>>>,
    pub fallback_distribution: RegisterView<C, Option<WeightedAliasIndex<u64>>>,
    pub proposed: RegisterView<C, Option<BlockProposal>>,
    pub proposed_blobs: MapView<C, BlobId, Blob>,
    pub locking_block: RegisterView<C, Option<LockingBlock>>,
    pub locking_blobs: MapView<C, BlobId, Blob>,
    pub timeout: RegisterView<C, Option<TimeoutCertificate>>,
    pub confirmed_vote: RegisterView<C, Option<Vote<ConfirmedBlock>>>,
    pub validated_vote: RegisterView<C, Option<Vote<ValidatedBlock>>>,
    pub timeout_vote: RegisterView<C, Option<Vote<Timeout>>>,
    pub fallback_vote: RegisterView<C, Option<Vote<Timeout>>>,
    pub round_timeout: RegisterView<C, Option<Timestamp>>,
    pub current_round: RegisterView<C, Round>,
    pub fallback_owners: RegisterView<C, BTreeMap<Owner, u64>>,
}

The state of the certification process for a chain’s next block.

Fields

ownership: RegisterView<C, ChainOwnership>

The public keys, weights and types of the chain’s owners.

seed: RegisterView<C, u64>

The seed for the pseudo-random number generator that determines the round leaders.

distribution: RegisterView<C, Option<WeightedAliasIndex<u64>>>

The probability distribution for choosing a round leader.

fallback_distribution: RegisterView<C, Option<WeightedAliasIndex<u64>>>

The probability distribution for choosing a fallback round leader.

proposed: RegisterView<C, Option<BlockProposal>>

Highest-round authenticated block that we have received and checked. If there are multiple proposals in the same round, this contains only the first one.

proposed_blobs: MapView<C, BlobId, Blob>

These are blobs published or read by the proposed block.

locking_block: RegisterView<C, Option<LockingBlock>>

Latest validated proposal that a validator may have voted to confirm. This is either the latest ValidatedBlock we have seen, or the proposal from the Fast round.

locking_blobs: MapView<C, BlobId, Blob>

These are blobs published or read by the locking block.

timeout: RegisterView<C, Option<TimeoutCertificate>>

Latest leader timeout certificate we have received.

confirmed_vote: RegisterView<C, Option<Vote<ConfirmedBlock>>>

Latest vote we cast to confirm a block.

validated_vote: RegisterView<C, Option<Vote<ValidatedBlock>>>

Latest vote we cast to validate a block.

timeout_vote: RegisterView<C, Option<Vote<Timeout>>>

Latest timeout vote we cast.

fallback_vote: RegisterView<C, Option<Vote<Timeout>>>

Fallback vote we cast.

round_timeout: RegisterView<C, Option<Timestamp>>

The time after which we are ready to sign a timeout certificate for the current round.

current_round: RegisterView<C, Round>

The lowest round where we can still vote to validate or confirm a block. This is the round to which the timeout applies.

Having a leader timeout certificate in any given round causes the next one to become current. Seeing a validated block certificate or a valid proposal in any round causes that round to become current, unless a higher one already is.

fallback_owners: RegisterView<C, BTreeMap<Owner, u64>>

The owners that take over in fallback mode.

Implementations

impl<C> ChainManager<C>

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

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

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

pub async fn proposed_blobs( &self, ctx: &Context<'_>, ) -> Result<&MapView<C, BlobId, Blob>>

pub async fn locking_blobs( &self, ctx: &Context<'_>, ) -> Result<&MapView<C, BlobId, Blob>>

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

pub async fn fallback_owners( &self, ctx: &Context<'_>, ) -> Result<&RegisterView<C, BTreeMap<Owner, u64>>>

impl<C> ChainManager<C>

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

pub fn reset<'a>( &mut self, ownership: ChainOwnership, height: BlockHeight, local_time: Timestamp, fallback_owners: impl Iterator<Item = (AccountPublicKey, u64)> + 'a, ) -> Result<(), ChainError>

Replaces self with a new chain manager.

pub fn confirmed_vote(&self) -> Option<&Vote<ConfirmedBlock>>

Returns the most recent confirmed vote we cast.

pub fn validated_vote(&self) -> Option<&Vote<ValidatedBlock>>

Returns the most recent validated vote we cast.

pub fn timeout_vote(&self) -> Option<&Vote<Timeout>>

Returns the most recent timeout vote we cast.

pub fn fallback_vote(&self) -> Option<&Vote<Timeout>>

Returns the most recent fallback vote we cast.

pub fn current_round(&self) -> Round

Returns the lowest round where we can still vote to validate or confirm a block. This is the round to which the timeout applies.

Having a leader timeout certificate in any given round causes the next one to become current. Seeing a validated block certificate or a valid proposal in any round causes that round to become current, unless a higher one already is.

pub fn check_proposed_block( &self, proposal: &BlockProposal, ) -> Result<Outcome, ChainError>

Verifies that a proposed block is relevant and should be handled.

pub fn vote_timeout( &mut self, chain_id: ChainId, height: BlockHeight, epoch: Epoch, key_pair: Option<&ValidatorSecretKey>, local_time: Timestamp, ) -> bool

Checks if the current round has timed out, and signs a Timeout.

pub fn vote_fallback( &mut self, chain_id: ChainId, height: BlockHeight, epoch: Epoch, key_pair: Option<&ValidatorSecretKey>, ) -> bool

Signs a Timeout certificate to switch to fallback mode.

This must only be called after verifying that the condition for fallback mode is satisfied locally.

pub fn check_validated_block( &self, certificate: &ValidatedBlockCertificate, ) -> Result<Outcome, ChainError>

Verifies that a validated block is still relevant and should be handled.

pub fn create_vote( &mut self, proposal: BlockProposal, executed_block: ExecutedBlock, key_pair: Option<&ValidatorSecretKey>, local_time: Timestamp, blobs: BTreeMap<BlobId, Blob>, ) -> Result<Option<ValidatedOrConfirmedVote<'_>>, ChainError>

Signs a vote to validate the proposed block.

pub fn create_final_vote( &mut self, validated: ValidatedBlockCertificate, key_pair: Option<&ValidatorSecretKey>, local_time: Timestamp, blobs: BTreeMap<BlobId, Blob>, ) -> Result<(), ViewError>

Signs a vote to confirm the validated block.

pub async fn pending_blob( &self, blob_id: &BlobId, ) -> Result<Option<Blob>, ViewError>

Returns the requested blob if it belongs to the proposal or the locking block.

pub fn handle_timeout_certificate( &mut self, certificate: TimeoutCertificate, local_time: Timestamp, )

Updates the round number and timer if the timeout certificate is from a higher round than any known certificate.

pub fn verify_owner(&self, proposal: &BlockProposal) -> bool

Returns whether the signer is a valid owner and allowed to propose a block in the proposal’s round.

Trait Implementations

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

where C: Clone + Context + Send + Sync + 'static, RegisterView<C, ChainOwnership>: Debug, RegisterView<C, u64>: Debug, RegisterView<C, Option<WeightedAliasIndex<u64>>>: Debug, RegisterView<C, Option<BlockProposal>>: Debug, MapView<C, BlobId, Blob>: Debug, RegisterView<C, Option<LockingBlock>>: Debug, RegisterView<C, Option<TimeoutCertificate>>: Debug, RegisterView<C, Option<Vote<ConfirmedBlock>>>: Debug, RegisterView<C, Option<Vote<ValidatedBlock>>>: Debug, RegisterView<C, Option<Vote<Timeout>>>: Debug, RegisterView<C, Option<Timestamp>>: Debug, RegisterView<C, Round>: Debug, RegisterView<C, BTreeMap<Owner, u64>>: Debug,

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

Formats the value using the given formatter.

impl<C> From<&ChainManager<C>> for ChainManagerInfo

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

fn from(manager: &ChainManager<C>) -> Self

Converts to this type from the input type.

impl<C> OutputType for ChainManager<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> View<C> for ChainManager<C>

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

const NUM_INIT_KEYS: usize = 14usize

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 ChainManager<C>

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