Struct hotshot_types::data::Leaf2

pub struct Leaf2<TYPES: NodeType> {
    view_number: TYPES::View,
    epoch: TYPES::Epoch,
    justify_qc: QuorumCertificate2<TYPES>,
    next_epoch_justify_qc: Option<NextEpochQuorumCertificate2<TYPES>>,
    parent_commitment: Commitment<Self>,
    block_header: TYPES::BlockHeader,
    upgrade_certificate: Option<UpgradeCertificate<TYPES>>,
    block_payload: Option<TYPES::BlockPayload>,
    pub view_change_evidence: Option<ViewChangeEvidence<TYPES>>,
    pub drb_seed: DrbSeedInput,
    pub drb_result: DrbResult,
}

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::View

CurView from leader when proposing leaf

epoch: TYPES::Epoch

An epoch to which the data belongs to. Relevant for validating against the correct stake table

justify_qc: QuorumCertificate2<TYPES>

Per spec, justification

next_epoch_justify_qc: Option<NextEpochQuorumCertificate2<TYPES>>

certificate that the proposal is chaining from formed by the next epoch nodes

parent_commitment: Commitment<Self>

The hash of the parent Leaf So we can ask if it extends

block_header: TYPES::BlockHeader

Block header.

upgrade_certificate: Option<UpgradeCertificate<TYPES>>

Optional upgrade certificate, if one was attached to the quorum proposal for this view.

block_payload: Option<TYPES::BlockPayload>

Optional block payload.

It may be empty for nodes not in the DA committee.

view_change_evidence: Option<ViewChangeEvidence<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.

drb_seed: DrbSeedInput

The DRB seed for the next epoch.

The DRB computation using this seed was started in the previous epoch.

drb_result: DrbResult

The DRB result for the current epoch.

The DRB computation with this result was started two epochs ago.

Implementations

impl<TYPES: NodeType> Leaf2<TYPES>

pub async fn genesis( validated_state: &TYPES::ValidatedState, instance_state: &TYPES::InstanceState, ) -> Self

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::View

Time when this leaf was created.

pub fn epoch(&self) -> TYPES::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) -> QuorumCertificate2<TYPES>

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

pub fn upgrade_certificate(&self) -> Option<UpgradeCertificate<TYPES>>

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

pub fn parent_commitment(&self) -> Commitment<Self>

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( &mut self, block_payload: TYPES::BlockPayload, num_storage_nodes: usize, ) -> Result<(), BlockError>

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::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::BlockPayload, )

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

pub fn block_payload(&self) -> Option<TYPES::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: &Self, decided_upgrade_certificate: &Arc<RwLock<Option<UpgradeCertificate<TYPES>>>>, ) -> Result<()>

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.

impl<TYPES: NodeType> Leaf2<TYPES>

pub fn from_quorum_proposal(quorum_proposal: &QuorumProposal2<TYPES>) -> Self

Constructs a leaf from a given quorum proposal.

Trait Implementations

impl<TYPES: Clone + NodeType> Clone for Leaf2<TYPES>

where TYPES::View: Clone, TYPES::Epoch: Clone, TYPES::BlockHeader: Clone, TYPES::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: NodeType> Committable for Leaf2<TYPES>

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<TYPES: Debug + NodeType> Debug for Leaf2<TYPES>

where TYPES::View: Debug, TYPES::Epoch: Debug, TYPES::BlockHeader: Debug, TYPES::BlockPayload: Debug,

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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

Converts to this type from the input type.

impl<TYPES: NodeType> Hash for Leaf2<TYPES>

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

fn eq(&self, other: &Self) -> 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: Serialize + NodeType, TYPES::View: Serialize, TYPES::Epoch: Serialize, TYPES::BlockHeader: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<TYPES: NodeType> TestableLeaf for Leaf2<TYPES>

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

type NodeType = TYPES

Type of nodes participating in the network.

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

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

impl<TYPES: Eq + NodeType> Eq for Leaf2<TYPES>

where TYPES::View: Eq, TYPES::Epoch: Eq, TYPES::BlockHeader: Eq, TYPES::BlockPayload: Eq,