Struct SessionReport 

pub struct SessionReport<AccountId> {
    pub end_index: SessionIndex,
    pub validator_points: Vec<(AccountId, u32)>,
    pub activation_timestamp: Option<(u64, u32)>,
    pub leftover: bool,
}

The information that is sent from RC -> AH on session end.

Fields

end_index: SessionIndex

The session that is ending.

This always implies start of end_index + 1, and planning of end_index + 2.

validator_points: Vec<(AccountId, u32)>

All of the points that validators have accumulated.

This can be either from block authoring, or from parachain consensus, or anything else.

activation_timestamp: Option<(u64, u32)>

If none, it means no new validator set was activated as a part of this session.

If Some((timestamp, id)), it means that the new validator set was activated at the given timestamp, and the id of the validator set is id.

This id is what was previously communicated to the RC as a part of ValidatorSetReport::id.

leftover: bool

If this session report is self-contained, then it is false.

If this session report has some leftover, it should not be acted upon until a subsequent message with leftover = true comes in. The client pallets should handle this queuing.

This is in place to future proof us against possibly needing to send multiple rounds of messages to convey all of the validator_points.

Upon processing, this should always be true, and it should be ignored.

Implementations

impl<AccountId> SessionReport<AccountId>

pub fn new_terminal( end_index: SessionIndex, validator_points: Vec<(AccountId, u32)>, activation_timestamp: Option<(u64, u32)>, ) -> Self

A new instance of self that is terminal. This is useful when we want to send everything in one go.

pub fn merge(self, other: Self) -> Result<Self, UnexpectedKind>

Merge oneself with another instance.

pub fn split(self, chunk_size: usize) -> Vec<Self>

where AccountId: Clone,

Split oneself into count number of pieces.

Trait Implementations

impl<AccountId: Clone> Clone for SessionReport<AccountId>

fn clone(&self) -> SessionReport<AccountId>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AccountId: Debug> Debug for SessionReport<AccountId>

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

Formats the value using the given formatter.

impl<AccountId> Decode for SessionReport<AccountId>

where Vec<(AccountId, u32)>: Decode,

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<AccountId> Display for SessionReport<AccountId>

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

Formats the value using the given formatter.

impl<AccountId> Encode for SessionReport<AccountId>

where Vec<(AccountId, u32)>: Encode,

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>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where 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<AccountId> MaxEncodedLen for SessionReport<AccountId>

where Vec<(AccountId, u32)>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<AccountId: PartialEq> PartialEq for SessionReport<AccountId>

fn eq(&self, other: &SessionReport<AccountId>) -> 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<AccountId: Clone> SplittableMessage for SessionReport<AccountId>

fn split_by(self, chunk_size: usize) -> Vec<Self>

Split yourself into pieces of chunk_size size.

fn len(&self) -> usize

Current length of the message.

impl<AccountId> TypeInfo for SessionReport<AccountId>

where Vec<(AccountId, u32)>: TypeInfo + 'static, AccountId: TypeInfo + 'static,

type Identity = SessionReport<AccountId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId> DecodeWithMemTracking for SessionReport<AccountId>

where Vec<(AccountId, u32)>: DecodeWithMemTracking,

impl<AccountId> EncodeLike for SessionReport<AccountId>

where Vec<(AccountId, u32)>: Encode,

impl<AccountId> StructuralPartialEq for SessionReport<AccountId>