Struct TimeoutCertificate3 

pub struct TimeoutCertificate3<T: NodeType> {
    pub view_number: ViewNumber,
    pub epoch: EpochNumber,
    pub latest: LatestTimeoutSignatures<T>,
    pub earlier: Vec<TimeoutSignatures<T>>,
}

A timeout certificate over TimeoutData3.

Every signer signs the lock it held when it timed out, so signers holding different locks sign different data. Signers holding the same lock form one group, whose signatures aggregate as in any other certificate. The certificate’s lock is the latest group’s, and that group carries the Certificate1 that shows the lock exists: a signer cannot claim a lock that no quorum certified. The lock is read from that certificate, so the two cannot disagree.

Fields

view_number: ViewNumber

The view that timed out.

epoch: EpochNumber

The epoch every signer named.

latest: LatestTimeoutSignatures<T>

The signers holding the certificate’s lock, the latest any signer holds.

earlier: Vec<TimeoutSignatures<T>>

The signers holding earlier locks, one aggregate per lock, earliest first.

Implementations

impl<T: NodeType> TimeoutCertificate3<T>

pub fn assemble( view: ViewNumber, epoch: EpochNumber, stake_table: &[<T::SignatureKey as SignatureKey>::StakeTableEntry], votes: impl IntoIterator<Item = (Option<LockView>, T::SignatureKey, <T::SignatureKey as SignatureKey>::PureAssembledSignatureType)>, lock_cert: Option<QuorumCertificate2<T>>, ) -> Result<Self>

Aggregate signed timeout votes into a certificate.

votes are each signer’s lock and signature over TimeoutData3 { view, epoch, lock }; they are not checked here. lock_cert must certify the latest of their locks.

pub fn lock(&self) -> Option<LockView>

The certificate’s lock: the latest lock any of its signers signed.

pub fn lock_cert(&self) -> Option<&QuorumCertificate2<T>>

The certificate of the certificate’s lock.

Only its LockView is verified unless the lock is recent (see LatestTimeoutSignatures::lock_cert).

pub fn timeout_lock(&self) -> TimeoutLock<'_, T>

The certificate’s lock, by what is checked of it.

pub fn data(&self, lock: Option<LockView>) -> TimeoutData3

The data the signers of the group holding lock signed.

fn groups( &self, ) -> impl Iterator<Item = (Option<LockView>, &<T::SignatureKey as SignatureKey>::QcType)>

Every group: its lock and aggregate signature, earliest lock first.

pub fn check_lock(&self) -> Result<()>

Check that the certificate’s lock is no later than its view and its epoch, as the lock of every honest signer is.

Needs no committee, so a certificate can be checked before the lock’s epoch is known.

pub fn check_signatures( &self, stake_table: &[<T::SignatureKey as SignatureKey>::StakeTableEntry], threshold: U256, upgrade_lock: &UpgradeLock<T>, ) -> Result<()>

Check everything but the lock certificate’s own signatures.

The earlier groups must be in lock order with no lock twice, all earlier than the certificate’s lock, which must pass Self::check_lock. Every group must have a signer, and no signer may be in two groups. Each group’s signature must be valid over its own data, and together the groups must reach threshold. That the lock certificate is signed by a quorum of its own epoch is Self::lock_epoch’s committee’s to check, and is not checked here: a certificate is valid only with both.

pub fn lock_epoch(&self) -> Option<EpochNumber>

The epoch whose committee signed the lock certificate.

Trait Implementations

impl<T: Clone + NodeType> Clone for TimeoutCertificate3<T>

fn clone(&self) -> TimeoutCertificate3<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: NodeType> Committable for TimeoutCertificate3<T>

Covers the lock certificate as sent. For a lock that is not checked, two certificates that differ only in the unverified parts of it both verify and commit differently, so the commitment does not identify the certificate’s signed content. Nothing keys on it: consensus keys timeout certificates by view, and a proposal’s leaf commitment covers the evidence its leader signed.

fn commit(&self) -> Commitment<Self>

Create a binding commitment to self.

fn tag() -> String

Tag that should be used when serializing commitments to this type.

impl<T: Debug + NodeType> Debug for TimeoutCertificate3<T>

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

Formats the value using the given formatter.

impl<'de, T: NodeType> Deserialize<'de> for TimeoutCertificate3<T>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Eq + NodeType> Eq for TimeoutCertificate3<T>

impl<T: NodeType> HasEpoch for TimeoutCertificate3<T>

fn epoch(&self) -> Option<EpochNumber>

Returns Epoch

impl<T: NodeType> HasViewNumber for TimeoutCertificate3<T>

fn view_number(&self) -> ViewNumber

Returns the view number the type refers to.

impl<T: Hash + NodeType> Hash for TimeoutCertificate3<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + NodeType> PartialEq for TimeoutCertificate3<T>

fn eq(&self, other: &TimeoutCertificate3<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> Serialize for TimeoutCertificate3<T>

where T: Serialize + NodeType,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq + NodeType> StructuralPartialEq for TimeoutCertificate3<T>