Enum pallet_capacity::pallet::Error

pub enum Error<T> {
    InvalidTarget,
    InsufficientCapacityBalance,
    StakingAmountBelowMinimum,
    ZeroAmountNotAllowed,
    NotAStakingAccount,
    NoUnstakedTokensAvailable,
    UnstakedAmountIsZero,
    InsufficientStakingBalance,
    StakerTargetRelationshipNotFound,
    TargetCapacityNotFound,
    MaxUnlockingChunksExceeded,
    IncreaseExceedsAvailable,
    MaxEpochLengthExceeded,
    BalanceTooLowtoStake,
    NoThawedTokenAvailable,
    CannotChangeStakingType,
    EraOutOfRange,
    CannotRetargetToSameProvider,
    NoRewardsEligibleToClaim,
    MustFirstClaimRewards,
    MaxRetargetsExceeded,
    CollectionBoundExceeded,
    NotAProviderBoostAccount,
    // some variants omitted
}

The Error enum of this pallet.

Variants

InvalidTarget

Staker attempted to stake to an invalid staking target.

InsufficientCapacityBalance

Capacity is not available for the given MSA.

StakingAmountBelowMinimum

Staker is attempting to stake an amount below the minimum amount.

ZeroAmountNotAllowed

Staker is attempting to stake a zero amount. DEPRECATED #[deprecated(since = “1.13.0”, note = “Use StakingAmountBelowMinimum instead”)]

NotAStakingAccount

This AccountId does not have a staking account.

NoUnstakedTokensAvailable

No staked value is available for withdrawal; either nothing is being unstaked, or nothing has passed the thaw period. (5)

UnstakedAmountIsZero

Unstaking amount should be greater than zero.

InsufficientStakingBalance

Amount to unstake or change targets is greater than the amount staked.

StakerTargetRelationshipNotFound

Attempted to get a staker / target relationship that does not exist.

TargetCapacityNotFound

Attempted to get the target’s capacity that does not exist.

MaxUnlockingChunksExceeded

Staker has reached the limit of unlocking chunks and must wait for at least one thaw period to complete. (10)

IncreaseExceedsAvailable

Capacity increase exceeds the total available Capacity for target.

MaxEpochLengthExceeded

Attempted to set the Epoch length to a value greater than the max Epoch length.

BalanceTooLowtoStake

Staker is attempting to stake an amount that leaves a token balance below the minimum amount.

NoThawedTokenAvailable

There are no unstaked token amounts that have passed their thaw period.

CannotChangeStakingType

Staker tried to change StakingType on an existing account

EraOutOfRange

The Era specified is too far in the past or is in the future (15)

CannotRetargetToSameProvider

Attempted to retarget but from and to Provider MSA Ids were the same

NoRewardsEligibleToClaim

There are no rewards eligible to claim. Rewards have expired, have already been claimed, or boosting has never been done before the current era.

MustFirstClaimRewards

Caller must claim rewards before unstaking.

MaxRetargetsExceeded

Too many change_staking_target calls made in this RewardEra. (20)

CollectionBoundExceeded

Tried to exceed bounds of a some Bounded collection

NotAProviderBoostAccount

This origin has nothing staked for ProviderBoost.

Trait Implementations

impl<T: Config> Debug for Error<T>

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

Formats the value using the given formatter.

impl<T> Decode for Error<T>

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<T> Encode for Error<T>

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<T: Config> From<Error<T>> for &'static str

fn from(err: Error<T>) -> &'static str

Converts to this type from the input type.

impl<T: Config> From<Error<T>> for DispatchError

fn from(err: Error<T>) -> Self

Converts to this type from the input type.

impl<T> PalletError for Error<T>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T> TypeInfo for Error<T>

where PhantomData<T>: TypeInfo + 'static, T: 'static,

type Identity = Error<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T> EncodeLike for Error<T>