Enum pallet_nomination_pools::pallet::Error

pub enum Error<T> {
    PoolNotFound,
    PoolMemberNotFound,
    RewardPoolNotFound,
    SubPoolsNotFound,
    AccountBelongsToOtherPool,
    FullyUnbonding,
    MaxUnbondingLimit,
    CannotWithdrawAny,
    MinimumBondNotMet,
    OverflowRisk,
    NotDestroying,
    NotNominator,
    NotKickerOrDestroying,
    NotOpen,
    MaxPools,
    MaxPoolMembers,
    CanNotChangeState,
    DoesNotHavePermission,
    MetadataExceedsMaxLen,
    Defensive(DefensiveError),
    PartialUnbondNotAllowedPermissionlessly,
    MaxCommissionRestricted,
    CommissionExceedsMaximum,
    CommissionExceedsGlobalMaximum,
    CommissionChangeThrottled,
    CommissionChangeRateNotAllowed,
    NoPendingCommission,
    NoCommissionCurrentSet,
    PoolIdInUse,
    InvalidPoolId,
    BondExtraRestricted,
    // some variants omitted
}

The Error enum of this pallet.

Variants

PoolNotFound

A (bonded) pool id does not exist.

PoolMemberNotFound

An account is not a member.

RewardPoolNotFound

A reward pool does not exist. In all cases this is a system logic error.

SubPoolsNotFound

A sub pool does not exist.

AccountBelongsToOtherPool

An account is already delegating in another pool. An account may only belong to one pool at a time.

FullyUnbonding

The member is fully unbonded (and thus cannot access the bonded and reward pool anymore to, for example, collect rewards).

MaxUnbondingLimit

The member cannot unbond further chunks due to reaching the limit.

CannotWithdrawAny

None of the funds can be withdrawn yet because the bonding duration has not passed.

MinimumBondNotMet

The amount does not meet the minimum bond to either join or create a pool.

The depositor can never unbond to a value less than Pallet::depositor_min_bond. The caller does not have nominating permissions for the pool. Members can never unbond to a value below MinJoinBond.

OverflowRisk

The transaction could not be executed due to overflow risk for the pool.

NotDestroying

A pool must be in PoolState::Destroying in order for the depositor to unbond or for other members to be permissionlessly unbonded.

NotNominator

The caller does not have nominating permissions for the pool.

NotKickerOrDestroying

Either a) the caller cannot make a valid kick or b) the pool is not destroying.

NotOpen

The pool is not open to join

MaxPools

The system is maxed out on pools.

MaxPoolMembers

Too many members in the pool or system.

CanNotChangeState

The pools state cannot be changed.

DoesNotHavePermission

The caller does not have adequate permissions.

MetadataExceedsMaxLen

Metadata exceeds Config::MaxMetadataLen

Defensive(DefensiveError)

Some error occurred that should never happen. This should be reported to the maintainers.

PartialUnbondNotAllowedPermissionlessly

Partial unbonding now allowed permissionlessly.

MaxCommissionRestricted

The pool’s max commission cannot be set higher than the existing value.

CommissionExceedsMaximum

The supplied commission exceeds the max allowed commission.

CommissionExceedsGlobalMaximum

The supplied commission exceeds global maximum commission.

CommissionChangeThrottled

Not enough blocks have surpassed since the last commission update.

CommissionChangeRateNotAllowed

The submitted changes to commission change rate are not allowed.

NoPendingCommission

There is no pending commission to claim.

NoCommissionCurrentSet

No commission current has been set.

PoolIdInUse

Pool id currently in use.

InvalidPoolId

Pool id provided is not correct/usable.

BondExtraRestricted

Bonding extra is restricted to the exact pending reward amount.

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, 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<T> From<DefensiveError> for Error<T>

fn from(e: DefensiveError) -> Error<T>

Converts to this type from the input type.

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 = 2usize

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