Struct parachain_staking::pallet::CollatorCandidate

pub struct CollatorCandidate<AccountId, Balance, CurrencyId> {
    pub id: AccountId,
    pub bond: Balance,
    pub liquidity_token: CurrencyId,
    pub delegators: OrderedSet<AccountId>,
    pub top_delegations: Vec<Bond<AccountId, Balance, CurrencyId>>,
    pub bottom_delegations: Vec<Bond<AccountId, Balance, CurrencyId>>,
    pub total_counted: Balance,
    pub total_backing: Balance,
    pub request: Option<CandidateBondRequest<Balance>>,
    pub state: CollatorStatus,
}

Collator candidate state with self bond + delegations

Fields

id: AccountId

The account of this collator

bond: Balance

This collator’s self stake.

liquidity_token: CurrencyId

This is the liquidity_token the collator uses

delegators: OrderedSet<AccountId>

Set of all delegator AccountIds (to prevent >1 delegation per AccountId)

top_delegations: Vec<Bond<AccountId, Balance, CurrencyId>>

Top T::MaxDelegatorsPerCollator::get() delegations, ordered greatest to least

bottom_delegations: Vec<Bond<AccountId, Balance, CurrencyId>>

Bottom delegations (unbounded), ordered least to greatest

total_counted: Balance

Sum of top delegations + self.bond

total_backing: Balance

Sum of all delegations + self.bond = (total_counted + uncounted)

request: Option<CandidateBondRequest<Balance>>

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

state: CollatorStatus

Current status of the collator

Implementations

impl<A, Balance, CurrencyId> CollatorCandidate<A, Balance, CurrencyId>where A: Ord + Clone + Debug, Balance: Default + PartialOrd + CheckedAdd + CheckedSub + Saturating + Ord + Copy, CurrencyId: Copy,

pub fn new(id: A, bond: Balance, liquidity_token: CurrencyId) -> Self

pub fn is_active(&self) -> bool

pub fn is_leaving(&self) -> bool

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

pub fn schedule_bond_more<T: Config>( &mut self, more: Balance, use_balance_from: Option<BondKind> ) -> Result<u32, DispatchError>where T::AccountId: From<A>, BalanceOf<T>: From<Balance>, CurrencyIdOf<T>: From<CurrencyId>,

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

pub fn schedule_bond_less<T: Config>( &mut self, less: Balance ) -> Result<u32, DispatchError>where BalanceOf<T>: From<Balance>, CurrencyIdOf<T>: From<CurrencyId>,

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

pub fn execute_pending_request<T: Config>( &mut self, use_balance_from: Option<BondKind> ) -> Result<Event<T>, DispatchError>where T::AccountId: From<A>, BalanceOf<T>: From<Balance>, CurrencyIdOf<T>: From<CurrencyId>,

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

pub fn cancel_pending_request<T: Config>( &mut self ) -> Result<Event<T>, DispatchError>where T::AccountId: From<A>, CandidateBondRequest<BalanceOf<T>>: From<CandidateBondRequest<Balance>>,

Cancel pending request to change the collator self bond

pub fn add_top_delegation(&mut self, delegation: Bond<A, Balance, CurrencyId>)

Infallible sorted insertion caller must verify !self.delegators.contains(delegation.owner) before call

pub fn add_bottom_delegation( &mut self, delegation: Bond<A, Balance, CurrencyId> )

Infallible sorted insertion caller must verify !self.delegators.contains(delegation.owner) before call

pub fn sort_top_delegations(&mut self)

Sort top delegations from greatest to least

pub fn sort_bottom_delegations(&mut self)

Sort bottom delegations from least to greatest

pub fn add_delegation<T: Config>( &mut self, acc: A, amount: Balance ) -> Result<DelegatorAdded<BalanceOf<T>>, DispatchError>where BalanceOf<T>: From<Balance>,

Bond account and add delegation. If successful, the return value indicates whether the delegation is top for the candidate.

pub fn rm_delegator<T: Config>( &mut self, delegator: A ) -> Result<(bool, Balance), DispatchError>

Return Ok((if_total_counted_changed, delegation_amount))

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

Return true if in_top after call

pub fn go_offline(&mut self)

pub fn go_online(&mut self)

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

Trait Implementations

impl<AccountId, Balance, CurrencyId> Debug for CollatorCandidate<AccountId, Balance, CurrencyId>where AccountId: Debug, Balance: Debug, CurrencyId: Debug,

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

Formats the value using the given formatter.

impl<AccountId, Balance, CurrencyId> Decode for CollatorCandidate<AccountId, Balance, CurrencyId>where AccountId: Decode, Balance: Decode, CurrencyId: Decode, OrderedSet<AccountId>: Decode, Vec<Bond<AccountId, Balance, CurrencyId>>: Decode, Option<CandidateBondRequest<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<AccountId, Balance, CurrencyId> Encode for CollatorCandidate<AccountId, Balance, CurrencyId>where AccountId: Encode, Balance: Encode, CurrencyId: Encode, OrderedSet<AccountId>: Encode, Vec<Bond<AccountId, Balance, CurrencyId>>: Encode, Option<CandidateBondRequest<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, 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<A: Clone, Balance, CurrencyId> From<CollatorCandidate<A, Balance, CurrencyId>> for CollatorSnapshot<A, Balance, CurrencyId>

fn from( other: CollatorCandidate<A, Balance, CurrencyId> ) -> CollatorSnapshot<A, Balance, CurrencyId>

Converts to this type from the input type.

impl<AccountId, Balance, CurrencyId> TypeInfo for CollatorCandidate<AccountId, Balance, CurrencyId>where AccountId: TypeInfo + 'static, Balance: TypeInfo + 'static, CurrencyId: TypeInfo + 'static, OrderedSet<AccountId>: TypeInfo + 'static, Vec<Bond<AccountId, Balance, CurrencyId>>: TypeInfo + 'static, Option<CandidateBondRequest<Balance>>: TypeInfo + 'static,

type Identity = CollatorCandidate<AccountId, Balance, CurrencyId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId, Balance, CurrencyId> EncodeLike<CollatorCandidate<AccountId, Balance, CurrencyId>> for CollatorCandidate<AccountId, Balance, CurrencyId>where AccountId: Encode, Balance: Encode, CurrencyId: Encode, OrderedSet<AccountId>: Encode, Vec<Bond<AccountId, Balance, CurrencyId>>: Encode, Option<CandidateBondRequest<Balance>>: Encode,