Enum Error

pub enum Error<T, I = ()> {
    XpNotFound,
    XpNotDead,
    InvalidXpOwner,
    AlreadyXpOwner,
    CannotReapLockedXp,
    XpLockExists,
    CannotGenerateXpKey,
    CannotTransferXp,
    LowPulseThreshold,
    InsufficientLiquidXp,
    TooManyLocks,
    TooManyReserves,
    XpLockNotFound,
    XpReserveNotFound,
    InvalidMinTimeStamp,
    LowTimeStamp,
    XpNotReaped,
    ReputationDeriveOverflowed,
    XpCapOverflowed,
    XpCapUnderflowed,
    XpComputationError,
    CannotLockZero,
    CannotReserveZero,
    XpAlreadyReaped,
    InsufficientReserveXp,
    XpReserveCapOverflowed,
    XpReserveCapUnderflowed,
    XpLockCapOverflowed,
    XpLockCapUnderflowed,
    // some variants omitted
}

XP Pallet Errors

Variants

XpNotFound

The specified XP key does not exist in the system.

XpNotDead

The XP entry is not considered “dead” and cannot be reaped.

InvalidXpOwner

The caller is not the owner of the XP key.

AlreadyXpOwner

The caller is already the owner of the XP key.

CannotReapLockedXp

Cannot reap an XP entry that still has active locks.

XpLockExists

A lock with the specified ID/Reason already exists for this XP key.

CannotGenerateXpKey

Failed to deterministically generate an XP key from the provided Preimage.

CannotTransferXp

Fungible Transfers are strictly forbidden in the XP system.

LowPulseThreshold

The provided threshold value is less than the per_count value, which is invalid.

InsufficientLiquidXp

Not enough liquid XP to lock the specified amount.

TooManyLocks

Maximum number of locks reached for this XP key.

TooManyReserves

Maximum number of reserves reached for this XP key.

XpLockNotFound

Lock with the specified ID/Reason was not found for this XP key.

XpReserveNotFound

Reserve with the specified Reason was not found for this XP key.

InvalidMinTimeStamp

The minimum timestamp must be less than the current block number.

LowTimeStamp

The XP entry’s timestamp is below the minimum required threshold.

XpNotReaped

The XP entry has not been reaped (finalized and removed).

ReputationDeriveOverflowed

Pulse-based reputation derivation overflowed.
Occurs when multiplying XP points by the pulse value overflows the scalar.

XpCapOverflowed

The maximum capacity of XP was exceeded due to an arithmetic operation.

XpCapUnderflowed

An arithmetic underflow occurred while subtracting XP points.

XpComputationError

An unexpected error occurred during XP computation. This is a general error for cases where XP calculations fail due to unforeseen issues in the logic or data.

CannotLockZero

Attempted to lock zero XP points (not allowed).

CannotReserveZero

Attempted to reserve zero XP points (not allowed).

XpAlreadyReaped

The XP entry has already been reaped (finalized) and cannot be reused.

InsufficientReserveXp

Not enough reserve XP is available to complete the operation.

XpReserveCapOverflowed

The maximum capacity of XP reserve was exceeded due to an arithmetic operation.

XpReserveCapUnderflowed

An arithmetic underflow occurred while subtracting reserved XP points.

XpLockCapOverflowed

The maximum capacity of XP lock was exceeded due to an arithmetic operation.

XpLockCapUnderflowed

An arithmetic underflow occurred while subtracting locked XP points.

Trait Implementations

impl<T: Config<I>, I: 'static> Debug for Error<T, I>

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

Formats the value using the given formatter.

impl<T, I> Decode for Error<T, I>

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

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

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

Converts to this type from the input type.

impl<T: Config<I>, I: 'static> From<Error<T, I>> for DispatchError

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

Converts to this type from the input type.

impl<T, I> PalletError for Error<T, I>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T, I> TypeInfo for Error<T, I>

where PhantomData<(T, I)>: TypeInfo + 'static, T: 'static, I: 'static,

type Identity = Error<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T, I> DecodeWithMemTracking for Error<T, I>

impl<T, I> EncodeLike for Error<T, I>