Struct hotshot_types::data::Leaf

pub struct Leaf<TYPES: NodeType> {
    view_number: TYPES::View,
    justify_qc: QuorumCertificate<TYPES>,
    parent_commitment: Commitment<Self>,
    block_header: TYPES::BlockHeader,
    upgrade_certificate: Option<UpgradeCertificate<TYPES>>,
    block_payload: Option<TYPES::BlockPayload>,
}

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. NOTE: State is constrained to implementing BlockContents, is TypeMap::BlockPayload

Fields

view_number: TYPES::View

CurView from leader when proposing leaf

justify_qc: QuorumCertificate<TYPES>

Per spec, justification

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.

Implementations

impl<TYPES: NodeType> Leaf<TYPES>

pub async fn commit<V: Versions>( &self, _upgrade_lock: &UpgradeLock<TYPES, V>, ) -> Commitment<Self>

Calculate the leaf commitment, which is gated on the version to include the block header.

impl<TYPES: NodeType> Leaf<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 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) -> QuorumCertificate<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> Leaf<TYPES>

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

Constructs a leaf from a given quorum proposal.

Trait Implementations

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

where TYPES::View: Clone, TYPES::BlockHeader: Clone, TYPES::BlockPayload: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TYPES: NodeType> Committable for Leaf<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 Leaf<TYPES>

where TYPES::View: 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 Leaf<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> Display for Leaf<TYPES>

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

Formats the value using the given formatter.

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 Leaf<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 Leaf<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 Leaf<TYPES>

where TYPES: Serialize + NodeType, TYPES::View: 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 Leaf<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 Leaf<TYPES>

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