Struct pallet_parachain_staking::types::CandidateMetadata

pub struct CandidateMetadata<Balance> {
    pub bond: Balance,
    pub delegation_count: u32,
    pub total_counted: Balance,
    pub lowest_top_delegation_amount: Balance,
    pub highest_bottom_delegation_amount: Balance,
    pub lowest_bottom_delegation_amount: Balance,
    pub top_capacity: CapacityStatus,
    pub bottom_capacity: CapacityStatus,
    pub request: Option<CandidateBondLessRequest<Balance>>,
    pub status: CollatorStatus,
}

All candidate info except the top and bottom delegations

Fields

bond: Balance

This candidate’s self bond amount

delegation_count: u32

Total number of delegations to this candidate

total_counted: Balance

Self bond + sum of top delegations

lowest_top_delegation_amount: Balance

The smallest top delegation amount

highest_bottom_delegation_amount: Balance

The highest bottom delegation amount

lowest_bottom_delegation_amount: Balance

The smallest bottom delegation amount

top_capacity: CapacityStatus

Capacity status for top delegations

bottom_capacity: CapacityStatus

Capacity status for bottom delegations

request: Option<CandidateBondLessRequest<Balance>>

Maximum 1 pending request to decrease candidate self bond at any given time

status: CollatorStatus

Current status of the collator

Implementations

impl<Balance: Copy + Zero + PartialOrd + AddAssign + SubAssign + Sub<Output = Balance> + Debug + Saturating> CandidateMetadata<Balance>

pub fn new(bond: Balance) -> Self

pub fn is_active(&self) -> bool

pub fn is_leaving(&self) -> bool

pub fn schedule_leave<T: Config>( &mut self ) -> Result<(RoundIndex, RoundIndex), DispatchError>

pub fn can_leave<T: Config>(&self) -> DispatchResult

pub fn go_offline(&mut self)

pub fn go_online(&mut self)

pub fn bond_more<T: Config>( &mut self, who: T::AccountId, more: Balance ) -> DispatchResult

where BalanceOf<T>: From<Balance>,

pub fn bond_less<T: Config>(&mut self, who: T::AccountId, amount: Balance)

where BalanceOf<T>: From<Balance>,

pub fn schedule_bond_less<T: Config>( &mut self, less: Balance ) -> Result<RoundIndex, DispatchError>

where BalanceOf<T>: Into<Balance>,

Schedule executable decrease of collator candidate self bond Returns the round at which the collator can execute the pending request

pub fn execute_bond_less<T: Config>( &mut self, who: T::AccountId ) -> DispatchResult

where BalanceOf<T>: From<Balance>,

Execute pending request to decrease the collator self bond Returns the event to be emitted

pub fn cancel_bond_less<T: Config>( &mut self, who: T::AccountId ) -> DispatchResult

where BalanceOf<T>: From<Balance>,

Cancel candidate bond less request

pub fn reset_top_data<T: Config>( &mut self, candidate: T::AccountId, top_delegations: &Delegations<T::AccountId, BalanceOf<T>> )

where BalanceOf<T>: Into<Balance> + From<Balance>,

Reset top delegations metadata

pub fn reset_bottom_data<T: Config>( &mut self, bottom_delegations: &Delegations<T::AccountId, BalanceOf<T>> )

where BalanceOf<T>: Into<Balance>,

Reset bottom delegations metadata

pub fn add_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegation: Bond<T::AccountId, BalanceOf<T>> ) -> Result<(DelegatorAdded<Balance>, Option<Balance>), DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Add delegation Returns whether delegator was added and an optional negative total counted remainder for if a bottom delegation was kicked MUST ensure no delegation exists for this candidate in the DelegatorState before call

pub fn add_top_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegation: Bond<T::AccountId, BalanceOf<T>> ) -> Option<Balance>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Add delegation to top delegation Returns Option<negative_total_staked_remainder> Only call if lowest top delegation is less than delegation.amount || !top_full

pub fn add_bottom_delegation<T: Config>( &mut self, bumped_from_top: bool, candidate: &T::AccountId, delegation: Bond<T::AccountId, BalanceOf<T>> )

where BalanceOf<T>: Into<Balance> + From<Balance>,

Add delegation to bottom delegations Check before call that if capacity is full, inserted delegation is higher than lowest bottom delegation (and if so, need to adjust the total storage item) CALLER MUST ensure(lowest_bottom_to_be_kicked.amount < delegation.amount)

pub fn rm_delegation_if_exists<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, amount: Balance ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Remove delegation Removes from top if amount is above lowest top or top is not full Return Ok(if_total_counted_changed)

pub fn rm_top_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Remove top delegation, bumps top bottom delegation if exists

pub fn rm_bottom_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance>,

Remove bottom delegation Returns if_total_counted_changed: bool

pub fn increase_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, bond: BalanceOf<T>, more: BalanceOf<T> ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Increase delegation amount

pub fn increase_top_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, more: BalanceOf<T> ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Increase top delegation

pub fn increase_bottom_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, bond: BalanceOf<T>, more: BalanceOf<T> ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Increase bottom delegation

pub fn decrease_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, bond: Balance, less: BalanceOf<T> ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Decrease delegation

pub fn decrease_top_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, bond: BalanceOf<T>, less: BalanceOf<T> ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance> + From<Balance>,

Decrease top delegation

pub fn decrease_bottom_delegation<T: Config>( &mut self, candidate: &T::AccountId, delegator: T::AccountId, less: BalanceOf<T> ) -> Result<bool, DispatchError>

where BalanceOf<T>: Into<Balance>,

Decrease bottom delegation

Trait Implementations

impl<Balance> Debug for CandidateMetadata<Balance>

where Balance: Debug,

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

Formats the value using the given formatter.

impl<Balance> Decode for CandidateMetadata<Balance>

where Balance: Decode, Option<CandidateBondLessRequest<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<Balance> Encode for CandidateMetadata<Balance>

where Balance: Encode, Option<CandidateBondLessRequest<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<Balance> TypeInfo for CandidateMetadata<Balance>

where Balance: TypeInfo + 'static, Option<CandidateBondLessRequest<Balance>>: TypeInfo + 'static,

type Identity = CandidateMetadata<Balance>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Balance> EncodeLike for CandidateMetadata<Balance>

where Balance: Encode, Option<CandidateBondLessRequest<Balance>>: Encode,