Struct sc_consensus_babe::Epoch

pub struct Epoch {
    pub epoch_index: u64,
    pub start_slot: Slot,
    pub duration: u64,
    pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
    pub randomness: [u8; 32],
    pub config: BabeEpochConfiguration,
}

BABE epoch information

Fields

epoch_index: u64

The epoch index.

start_slot: Slot

The starting slot of the epoch.

duration: u64

The duration of this epoch.

authorities: Vec<(AuthorityId, BabeAuthorityWeight)>

The authorities and their weights.

randomness: [u8; 32]

Randomness for this epoch.

config: BabeEpochConfiguration

Configuration of the epoch.

Implementations

impl Epoch

pub fn genesis(genesis_config: &BabeConfiguration, slot: Slot) -> Epoch

Create the genesis epoch (epoch #0).

This is defined to start at the slot of the first block, so that has to be provided.

pub fn clone_for_slot(&self, slot: Slot) -> Epoch

Clone and tweak epoch information to refer to the specified slot.

All the information which depends on the slot value is recomputed and assigned to the returned epoch instance.

The slot must be greater than or equal the original epoch start slot, if is less this operation is equivalent to a simple clone.

Trait Implementations

impl Clone for Epoch

fn clone(&self) -> Epoch

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Epoch

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

Formats the value using the given formatter.

impl Decode for Epoch

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>(
    input: &mut I,
    dst: &mut MaybeUninit<Self>
) -> Result<DecodeFinished, Error>where
    I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where
    I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for Epoch

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl Epoch for Epoch

type NextEpochDescriptor = (NextEpochDescriptor, BabeEpochConfiguration)

Descriptor for the next epoch.

type Slot = Slot

Type of the slot number.

fn increment(
    &self,
    (descriptor, config): (NextEpochDescriptor, BabeEpochConfiguration)
) -> Epoch

Increment the epoch data, using the next epoch descriptor.

fn start_slot(&self) -> Slot

The starting slot of the epoch.

fn end_slot(&self) -> Slot

Produce the “end slot” of the epoch. This is NOT inclusive to the epoch, i.e. the slots covered by the epoch are self.start_slot() .. self.end_slot().

impl From<Epoch> for Epoch

fn from(epoch: Epoch) -> Self

Converts to this type from the input type.

impl PartialEq<Epoch> for Epoch

fn eq(&self, other: &Epoch) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeInfo for Epoch

type Identity = Epoch

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike<Epoch> for Epoch

impl Eq for Epoch

impl StructuralEq for Epoch

impl StructuralPartialEq for Epoch