Struct Leaf2

pub struct Leaf2<TYPES>
where
    TYPES: NodeType,
{
    view_number: <TYPES as NodeType>::View,
    justify_qc: SimpleCertificate<TYPES, QuorumData2<TYPES>, SuccessThreshold>,
    next_epoch_justify_qc: Option<SimpleCertificate<TYPES, NextEpochQuorumData2<TYPES>, SuccessThreshold>>,
    parent_commitment: Commitment<Leaf2<TYPES>>,
    block_header: <TYPES as NodeType>::BlockHeader,
    upgrade_certificate: Option<SimpleCertificate<TYPES, UpgradeProposalData<TYPES>, UpgradeThreshold>>,
    block_payload: Option<<TYPES as NodeType>::BlockPayload>,
    pub view_change_evidence: Option<ViewChangeEvidence2<TYPES>>,
    pub next_drb_result: Option<[u8; 32]>,
    pub with_epoch: bool,
}

This is the consensus-internal analogous concept to a block, and it contains the block proper, as well as the hash of its parent Leaf.

Fields

view_number: <TYPES as NodeType>::View

justify_qc: SimpleCertificate<TYPES, QuorumData2<TYPES>, SuccessThreshold>

next_epoch_justify_qc: Option<SimpleCertificate<TYPES, NextEpochQuorumData2<TYPES>, SuccessThreshold>>

parent_commitment: Commitment<Leaf2<TYPES>>

block_header: <TYPES as NodeType>::BlockHeader

upgrade_certificate: Option<SimpleCertificate<TYPES, UpgradeProposalData<TYPES>, UpgradeThreshold>>

block_payload: Option<<TYPES as NodeType>::BlockPayload>

view_change_evidence: Option<ViewChangeEvidence2<TYPES>>

Possible timeout or view sync certificate. If the justify_qc is not for a proposal in the immediately preceding view, then either a timeout or view sync certificate must be attached.

next_drb_result: Option<[u8; 32]>

The DRB result for the next epoch.

This is required only for the last block of the epoch. Nodes will verify that it’s consistent with the result from their computations.

with_epoch: bool

Indicates whether or not epochs were enabled.

Implementations

impl<TYPES> Leaf2<TYPES>

where TYPES: NodeType,

pub async fn genesis<V>( validated_state: &<TYPES as NodeType>::ValidatedState, instance_state: &<TYPES as NodeType>::InstanceState, ) -> Leaf2<TYPES>

where V: Versions,

Create a new leaf from its components.

Panics

Panics if the genesis payload (TYPES::BlockPayload::genesis()) is malformed (unable to be interpreted as bytes).

pub fn view_number(&self) -> <TYPES as NodeType>::View

Time when this leaf was created.

pub fn epoch(&self, epoch_height: u64) -> Option<<TYPES as NodeType>::Epoch>

Epoch in which this leaf was created.

pub fn height(&self) -> u64

Height of this leaf in the chain.

Equivalently, this is the number of leaves before this one in the chain.

pub fn justify_qc( &self, ) -> SimpleCertificate<TYPES, QuorumData2<TYPES>, SuccessThreshold>

The QC linking this leaf to its parent in the chain.

pub fn upgrade_certificate( &self, ) -> Option<SimpleCertificate<TYPES, UpgradeProposalData<TYPES>, UpgradeThreshold>>

The QC linking this leaf to its parent in the chain.

pub fn parent_commitment(&self) -> Commitment<Leaf2<TYPES>>

Commitment to this leaf’s parent.

pub fn block_header(&self) -> &<TYPES as NodeType>::BlockHeader

The block header contained in this leaf.

pub fn block_header_mut(&mut self) -> &mut <TYPES as NodeType>::BlockHeader

Get a mutable reference to the block header contained in this leaf.

pub fn fill_block_payload<V>( &mut self, block_payload: <TYPES as NodeType>::BlockPayload, num_storage_nodes: usize, version: Version, ) -> Result<(), BlockError>

where V: Versions,

Fill this leaf with the block payload.

Errors

Fails if the payload commitment doesn’t match self.block_header.payload_commitment() or if the transactions are of invalid length

pub fn unfill_block_payload( &mut self, ) -> Option<<TYPES as NodeType>::BlockPayload>

Take the block payload from the leaf and return it if it is present

pub fn fill_block_payload_unchecked( &mut self, block_payload: <TYPES as NodeType>::BlockPayload, )

Fill this leaf with the block payload, without checking header and payload consistency

pub fn block_payload(&self) -> Option<<TYPES as NodeType>::BlockPayload>

Optional block payload.

pub fn payload_commitment(&self) -> VidCommitment

A commitment to the block payload contained in this leaf.

pub async fn extends_upgrade( &self, parent: &Leaf2<TYPES>, decided_upgrade_certificate: &Arc<RwLock<Option<SimpleCertificate<TYPES, UpgradeProposalData<TYPES>, UpgradeThreshold>>>>, ) -> Result<(), Error>

Validate that a leaf has the right upgrade certificate to be the immediate child of another leaf

This may not be a complete function. Please double-check that it performs the checks you expect before substituting validation logic with it.

Errors

Returns an error if the certificates are not identical, or that when we no longer see a cert, it’s for the right reason.

pub fn to_leaf_unsafe(self) -> Leaf<TYPES>

Converts a Leaf2 to a Leaf. This operation is fundamentally unsafe and should not be used.

impl<TYPES> Leaf2<TYPES>

where TYPES: NodeType,

pub fn from_quorum_proposal( quorum_proposal: &QuorumProposalWrapper<TYPES>, ) -> Leaf2<TYPES>

Constructs a leaf from a given quorum proposal.

Trait Implementations

impl<TYPES> Clone for Leaf2<TYPES>

where TYPES: Clone + NodeType, <TYPES as NodeType>::View: Clone, <TYPES as NodeType>::BlockHeader: Clone, <TYPES as NodeType>::BlockPayload: Clone,

fn clone(&self) -> Leaf2<TYPES>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TYPES> Committable for Leaf2<TYPES>

where TYPES: NodeType,

fn commit(&self) -> Commitment<Leaf2<TYPES>>

Create a binding commitment to self.

fn tag() -> String

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

impl<TYPES> Debug for Leaf2<TYPES>

where TYPES: Debug + NodeType, <TYPES as NodeType>::View: Debug, <TYPES as NodeType>::BlockHeader: Debug, <TYPES as NodeType>::BlockPayload: Debug,

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

Formats the value using the given formatter.

impl<'de, TYPES> Deserialize<'de> for Leaf2<TYPES>

where TYPES: NodeType,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Leaf2<TYPES>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<TYPES> From<Leaf<TYPES>> for Leaf2<TYPES>

where TYPES: NodeType,

fn from(leaf: Leaf<TYPES>) -> Leaf2<TYPES>

Converts to this type from the input type.

impl<TYPES> Hash for Leaf2<TYPES>

where TYPES: NodeType,

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

where H: Hasher,

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<TYPES> PartialEq for Leaf2<TYPES>

where TYPES: NodeType,

fn eq(&self, other: &Leaf2<TYPES>) -> 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<TYPES> Serialize for Leaf2<TYPES>

where TYPES: NodeType + Serialize, <TYPES as NodeType>::View: Serialize, <TYPES as NodeType>::BlockHeader: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<TYPES> TestableLeaf for Leaf2<TYPES>

where TYPES: NodeType, <TYPES as NodeType>::ValidatedState: TestableState<TYPES>, <TYPES as NodeType>::BlockPayload: TestableBlock<TYPES>,

type NodeType = TYPES

Type of nodes participating in the network.

fn create_random_transaction( &self, rng: &mut dyn RngCore, padding: u64, ) -> <<<Leaf2<TYPES> as TestableLeaf>::NodeType as NodeType>::BlockPayload as BlockPayload<<Leaf2<TYPES> as TestableLeaf>::NodeType>>::Transaction

Create a transaction that can be added to the block contained in this leaf.

impl<TYPES> Eq for Leaf2<TYPES>

where TYPES: Eq + NodeType, <TYPES as NodeType>::View: Eq, <TYPES as NodeType>::BlockHeader: Eq, <TYPES as NodeType>::BlockPayload: Eq,