Struct LiteCertificate 

pub struct LiteCertificate<'a> {
    pub value: LiteValue,
    pub round: Round,
    pub unlocking_round: Option<Round>,
    pub first_round: bool,
    pub justification_commitment: Option<CryptoHash>,
    pub justification: Cow<'a, JustificationChain>,
    pub signatures: Cow<'a, [(ValidatorPublicKey, ValidatorSignature)]>,
}

A certified statement from the committee, without the value.

Fields

value: LiteValue

Hash and chain ID of the certified value (used as key for storage).

round: Round

The round in which the value was certified.

unlocking_round: Option<Round>

The unlocking round the ValidatedBlock voters signed (see VoteValue). Always None for ConfirmedBlock/Timeout certificates and for validated blocks with no justification.

first_round: bool

The first-round attestation the ConfirmedBlock voters signed (see VoteValue). Only true for a ConfirmedBlock certificate confirming a block in the chain’s first round; always false for ValidatedBlock/Timeout certificates.

justification_commitment: Option<CryptoHash>

The justification commitment the voters signed (see VoteValue): the hash of the carried chain’s top link, or None if the chain is empty.

justification: Cow<'a, JustificationChain>

The justification chain attached to this certificate: for a ValidatedBlock certificate it is the chain of validated quorums in rounds below round; for a ConfirmedBlock certificate it is the full chain of validated quorums up to and including the confirm round. Empty for Timeout certificates and for blocks needing no justification. Borrowed, like signatures, so building a lite certificate from a full one never clones the chain.

signatures: Cow<'a, [(ValidatorPublicKey, ValidatorSignature)]>

Signatures on the value.

Implementations

impl LiteCertificate<'_>

pub fn new_with_payload( value: LiteValue, round: Round, unlocking_round: Option<Round>, first_round: bool, justification_commitment: Option<CryptoHash>, signatures: Vec<(ValidatorPublicKey, ValidatorSignature)>, ) -> Self

Creates a new lite certificate that records the signed payload fields beyond the value and round: the unlocking round its ValidatedBlock voters signed, the first-round attestation its ConfirmedBlock voters signed, and the justification commitment (see VoteValue) — with an empty justification chain.

pub fn try_from_votes( votes: impl IntoIterator<Item = (ValidatorPublicKey, LiteVote)>, ) -> Option<Self>

Creates a LiteCertificate from a list of votes with their validator public keys, without cryptographically checking the signatures. Returns None if the votes are empty or don’t have matching values and rounds.

pub fn check(&self, committee: &Committee) -> Result<&LiteValue, ChainError>

Verifies the certificate: its signatures, its justification chain, and that the signed unlocking round and first-round attestation are bound to that chain exactly as ValidatedBlockCertificate::check and ConfirmedBlockCertificate::check require. This is the single verification the worker applies to the certificate a retry proposal carries, so it must reject a stripped or mismatched chain, not just check the pieces in isolation.

pub fn full_justification(&self) -> JustificationChain

Returns the full justification chain that a certificate validating in a higher round would carry below itself: the chain it already carries, with this certificate’s own quorum appended as the new top link.

pub fn full_justification_commitment(&self) -> CryptoHash

Returns the justification commitment that a vote citing this certificate signs: the hash of this certificate’s own quorum as a CommittedQuorum, which transitively commits to the chain below it. Equals full_justification’s commitment.

pub fn check_value<T: CertificateValue>(&self, value: &T) -> bool

Checks whether the value matches this certificate.

pub fn with_value<T: CertificateValue>( self, value: T, ) -> Option<GenericCertificate<T>>

Returns the GenericCertificate with the specified value, if it matches. The justification chain is dropped; use into_confirmed_certificate or into_validated_certificate to keep it.

pub fn into_confirmed_certificate( self, value: ConfirmedBlock, ) -> Option<ConfirmedBlockCertificate>

Consumes this lite certificate into the full ConfirmedBlockCertificate for value, carrying the justification chain across (never cloning it). Returns None if the value does not match.

pub fn into_validated_certificate( self, value: ValidatedBlock, ) -> Option<ValidatedBlockCertificate>

Consumes this lite certificate into the full ValidatedBlockCertificate for value, carrying the justification chain across (never cloning it). Returns None if the value does not match.

pub fn cloned(&self) -> LiteCertificate<'static>

Returns a LiteCertificate that owns its signatures and justification chain.

Trait Implementations

impl Allocative for LiteCertificate<'_>

fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>)

impl<'a> Clone for LiteCertificate<'a>

fn clone(&self) -> LiteCertificate<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for LiteCertificate<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for LiteCertificate<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for LiteCertificate<'a>

fn eq(&self, other: &LiteCertificate<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for LiteCertificate<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for LiteCertificate<'a>

impl<'a> StructuralPartialEq for LiteCertificate<'a>