Enum hotshot_types::utils::ViewInner

pub enum ViewInner<TYPES: NodeType> {
    Da {
        payload_commitment: VidCommitment,
        epoch: TYPES::Epoch,
    },
    Leaf {
        leaf: LeafCommitment<TYPES>,
        state: Arc<TYPES::ValidatedState>,
        delta: Option<Arc<<TYPES::ValidatedState as ValidatedState<TYPES>>::Delta>>,
        epoch: TYPES::Epoch,
    },
    Failed,
}

A view’s state

Variants

Da

A pending view with an available block but not leaf proposal yet.

Storing this state allows us to garbage collect blocks for views where a proposal is never made. This saves memory when a leader fails and subverts a DoS attack where malicious leaders repeatedly request availability for blocks that they never propose.

Fields

payload_commitment: VidCommitment

Payload commitment to the available block.

epoch: TYPES::Epoch

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

Leaf

Undecided view

Fields

leaf: LeafCommitment<TYPES>

Proposed leaf

state: Arc<TYPES::ValidatedState>

Validated state.

delta: Option<Arc<<TYPES::ValidatedState as ValidatedState<TYPES>>::Delta>>

Optional state delta.

epoch: TYPES::Epoch

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

Failed

Leaf has failed

Implementations

impl<TYPES: NodeType> ViewInner<TYPES>

pub fn leaf_and_state( &self, ) -> Option<(LeafCommitment<TYPES>, &Arc<TYPES::ValidatedState>)>

Return the underlying undecide leaf commitment and validated state if they exist.

pub fn leaf_commitment(&self) -> Option<LeafCommitment<TYPES>>

return the underlying leaf hash if it exists

pub fn state(&self) -> Option<&Arc<TYPES::ValidatedState>>

return the underlying validated state if it exists

pub fn state_and_delta(&self) -> StateAndDelta<TYPES>

Return the underlying validated state and state delta if they exist.

pub fn payload_commitment(&self) -> Option<VidCommitment>

return the underlying block paylod commitment if it exists

pub fn epoch(&self) -> Option<TYPES::Epoch>

Returns Epoch if possible

Trait Implementations

impl<TYPES: NodeType> Clone for ViewInner<TYPES>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TYPES: Debug + NodeType> Debug for ViewInner<TYPES>

where TYPES::Epoch: Debug, TYPES::ValidatedState: Debug,

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<TYPES: PartialEq + NodeType> PartialEq for ViewInner<TYPES>

where TYPES::Epoch: PartialEq, TYPES::ValidatedState: PartialEq,

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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

where TYPES::Epoch: Eq, TYPES::ValidatedState: Eq,

impl<TYPES: NodeType> StructuralPartialEq for ViewInner<TYPES>