Struct hotshot_types::data::vid_disperse::ADVZDisperse

pub struct ADVZDisperse<TYPES: NodeType> {
    pub view_number: TYPES::View,
    pub epoch: Option<TYPES::Epoch>,
    pub target_epoch: Option<TYPES::Epoch>,
    pub payload_commitment: VidCommitment,
    pub data_epoch_payload_commitment: Option<VidCommitment>,
    pub shares: BTreeMap<TYPES::SignatureKey, VidShare>,
    pub common: VidCommon,
}

ADVZ dispersal data

Fields

view_number: TYPES::View

The view number for which this VID data is intended

epoch: Option<TYPES::Epoch>

Epoch the data of this proposal belongs to

target_epoch: Option<TYPES::Epoch>

Epoch to which the recipients of this VID belong to

payload_commitment: VidCommitment

VidCommitment calculated based on the number of nodes in target_epoch.

data_epoch_payload_commitment: Option<VidCommitment>

VidCommitment calculated based on the number of nodes in epoch. Needed during epoch transition.

shares: BTreeMap<TYPES::SignatureKey, VidShare>

A storage node’s key and its corresponding VID share

common: VidCommon

VID common data sent to all storage nodes

Implementations

impl<TYPES: NodeType> ADVZDisperse<TYPES>

pub async fn from_membership( view_number: TYPES::View, vid_disperse: JfVidDisperse<VidSchemeType>, membership: &Arc<RwLock<TYPES::Membership>>, target_epoch: Option<TYPES::Epoch>, data_epoch: Option<TYPES::Epoch>, data_epoch_payload_commitment: Option<VidCommitment>, ) -> Self

Create VID dispersal from a specified membership for the target epoch. Uses the specified function to calculate share dispersal Allows for more complex stake table functionality

pub async fn calculate_vid_disperse( payload: &TYPES::BlockPayload, membership: &Arc<RwLock<TYPES::Membership>>, view: TYPES::View, target_epoch: Option<TYPES::Epoch>, data_epoch: Option<TYPES::Epoch>, ) -> Result<Self>

Calculate the vid disperse information from the payload given a view, epoch and membership, If the sender epoch is missing, it means it’s the same as the target epoch.

Errors

Returns an error if the disperse or commitment calculation fails

Trait Implementations

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

where TYPES::View: Clone, TYPES::Epoch: Clone, TYPES::SignatureKey: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where TYPES::View: Debug, TYPES::Epoch: Debug, TYPES::SignatureKey: Debug,

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

Formats the value using the given formatter.

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

where TYPES::View: Deserialize<'de>,

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<ADVZDisperse<TYPES>> for VidDisperse<TYPES>

fn from(disperse: ADVZDisperse<TYPES>) -> Self

Converts to this type from the input type.

impl<TYPES: NodeType> HasEpoch<TYPES> for ADVZDisperse<TYPES>

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

Returns Epoch

impl<TYPES: NodeType> HasViewNumber<TYPES> for ADVZDisperse<TYPES>

fn view_number(&self) -> TYPES::View

Returns the view number the type refers to.

impl<TYPES: Hash + NodeType> Hash for ADVZDisperse<TYPES>

where TYPES::View: Hash, TYPES::Epoch: Hash, TYPES::SignatureKey: Hash,

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

where TYPES::View: PartialEq, TYPES::Epoch: PartialEq, TYPES::SignatureKey: PartialEq,

fn eq(&self, other: &ADVZDisperse<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 ADVZDisperse<TYPES>

where TYPES::View: 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: Eq + NodeType> Eq for ADVZDisperse<TYPES>

where TYPES::View: Eq, TYPES::Epoch: Eq, TYPES::SignatureKey: Eq,

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