Struct pallet_parachain_staking::types::Delegations

pub struct Delegations<AccountId, Balance> {
    pub delegations: Vec<Bond<AccountId, Balance>>,
    pub total: Balance,
}

Type for top and bottom delegation storage item

Fields

delegations: Vec<Bond<AccountId, Balance>>

total: Balance

Implementations

impl<AccountId, Balance: Copy + Ord + AddAssign + Zero + Saturating> Delegations<AccountId, Balance>

pub fn sort_greatest_to_least(&mut self)

pub fn insert_sorted_greatest_to_least( &mut self, delegation: Bond<AccountId, Balance> )

Insert sorted greatest to least and increase .total accordingly Insertion respects first come first serve so new delegations are pushed after existing delegations if the amount is the same

pub fn top_capacity<T: Config>(&self) -> CapacityStatus

Return the capacity status for top delegations

pub fn bottom_capacity<T: Config>(&self) -> CapacityStatus

Return the capacity status for bottom delegations

pub fn lowest_delegation_amount(&self) -> Balance

Return last delegation amount without popping the delegation

pub fn highest_delegation_amount(&self) -> Balance

Return highest delegation amount

Trait Implementations

impl<AccountId: Clone, Balance: Clone> Clone for Delegations<AccountId, Balance>

fn clone(&self) -> Delegations<AccountId, Balance>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AccountId, Balance> Debug for Delegations<AccountId, Balance>

where AccountId: Debug, Balance: Debug,

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

Formats the value using the given formatter.

impl<AccountId, Balance> Decode for Delegations<AccountId, Balance>

where Vec<Bond<AccountId, Balance>>: Decode, Balance: 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<A, B: Default> Default for Delegations<A, B>

fn default() -> Delegations<A, B>

Returns the “default value” for a type.

impl<AccountId, Balance> Encode for Delegations<AccountId, Balance>

where Vec<Bond<AccountId, Balance>>: Encode, Balance: 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, Balance> TypeInfo for Delegations<AccountId, Balance>

where Vec<Bond<AccountId, Balance>>: TypeInfo + 'static, Balance: TypeInfo + 'static, AccountId: TypeInfo + 'static,

type Identity = Delegations<AccountId, Balance>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId, Balance> EncodeLike for Delegations<AccountId, Balance>

where Vec<Bond<AccountId, Balance>>: Encode, Balance: Encode,