Struct gekko::runtime::polkadot::extrinsics::staking::Unbond

pub struct Unbond<A> where
    A: Encode + Decode,  {
    pub value: A,
}

Schedule a portion of the stash to be unlocked ready for transfer out after the bond

Documentation (provided by the runtime metadata)

Schedule a portion of the stash to be unlocked ready for transfer out after the bond period ends. If this leaves an amount actively bonded less than T::Currency::minimum_balance(), then it is increased to the full amount.

Once the unlock period is done, you can call withdraw_unbonded to actually move the funds out of management ready for transfer.

No more than a limited number of unlocking chunks (see MAX_UNLOCKING_CHUNKS) can co-exists at the same time. In that case, Call::withdraw_unbonded need to be called first to remove some of the chunks (if possible).

If a user encounters the InsufficientBond error when calling this extrinsic, they should call chill first in order to free up their bonded funds.

The dispatch origin for this call must be Signed by the controller, not the stash. And, it can be only called when EraElectionStatus is Closed.

Emits Unbonded.

See also Call::withdraw_unbonded.

• Independent of the arguments. Limited but potentially exploitable complexity.
• Contains a limited number of reads.
• Each call (requires the remainder of the bonded balance to be above minimum_balance) will cause a new entry to be inserted into a vector (Ledger.unlocking) kept in storage. The only way to clean the aforementioned storage item is also user-controlled via withdraw_unbonded.
• One DB entry.

---

Weight: O(1) DB Weight:

• Read: EraElectionStatus, Ledger, CurrentEra, Locks, BalanceOf Stash,
• Write: Locks, Ledger, BalanceOf Stash,

Type Disclaimer

This library makes no assumptions about parameter types and must be specified manually as generic types. Each field contains a type description which can serve as a hint on what type is being expected, as provided by the runtime meatadata. See the common module for common types which can be used.

Fields

value: A

Type description: Compact<BalanceOf<T>>

Trait Implementations

impl<A: Clone> Clone for Unbond<A> where
    A: Encode + Decode, 

fn clone(&self) -> Unbond<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Unbond<A> where
    A: Encode + Decode, 

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

Formats the value using the given formatter.

impl<A> Decode for Unbond<A> where
    A: Encode + Decode, 

fn decode<SI: Input>(input: &mut SI) -> Result<Self, Error>

Attempt to deserialise the value from input.

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> Encode for Unbond<A> where
    A: Encode + Decode, 

fn using_encoded<SR, SF: FnOnce(&[u8]) -> SR>(&self, f: SF) -> SR

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

fn size_hint(&self) -> usize

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

fn encode_to<T>(&self, dest: &mut T) where
    T: Output + ?Sized, 

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

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

Convert self to an owned vector.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<A: PartialEq> PartialEq<Unbond<A>> for Unbond<A> where
    A: Encode + Decode, 

fn eq(&self, other: &Unbond<A>) -> bool

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

fn ne(&self, other: &Unbond<A>) -> bool

This method tests for !=.

impl<A: Eq> Eq for Unbond<A> where
    A: Encode + Decode, 

impl<A> StructuralEq for Unbond<A> where
    A: Encode + Decode, 

impl<A> StructuralPartialEq for Unbond<A> where
    A: Encode + Decode,