Enum pallet_pool_system::pallet::Error

pub enum Error<T> {
    PoolInUse,
    InvalidJuniorTranche,
    InvalidTrancheStructure,
    NoSuchPool,
    MinEpochTimeHasNotPassed,
    ChallengeTimeHasNotPassed,
    InSubmissionPeriod,
    NAVTooOld,
    TrancheId,
    WipedOut,
    InvalidSolution,
    NotInSubmissionPeriod,
    InsufficientCurrency,
    RiskBufferViolated,
    NoNAV,
    EpochNotExecutedYet,
    CannotAddOrRemoveTranches,
    InvalidTrancheSeniority,
    InvalidTrancheUpdate,
    MetadataForCurrencyNotFound,
    TrancheTokenNameTooLong,
    TrancheSymbolNameTooLong,
    FailedToRegisterTrancheMetadata,
    FailedToUpdateTrancheMetadata,
    InvalidTrancheId,
    TooManyTranches,
    NotNewBestSubmission,
    NoSolutionAvailable,
    PoolParameterBoundViolated,
    NoScheduledUpdate,
    ScheduledTimeHasNotPassed,
    UpdatePrerequesitesNotFulfilled,
    InvalidCurrency,
    ChangeNotFound,
    ChangeNotReady,
    // some variants omitted
}

The Error enum of this pallet.

Variants

PoolInUse

A pool with this ID is already in use

InvalidJuniorTranche

Attempted to create a pool without a junior tranche

InvalidTrancheStructure

Attempted to create a tranche structure where

• non-decreasing interest rate per tranche

NoSuchPool

Attempted an operation on a pool which does not exist

MinEpochTimeHasNotPassed

Attempted to close an epoch too early

ChallengeTimeHasNotPassed

Attempted to execute an epoch too early

InSubmissionPeriod

Cannot be called while the pool is in a submission period

NAVTooOld

Attempted to close an epoch with an out of date NAV

TrancheId

A Tranche ID cannot be converted to an address

WipedOut

Closing the epoch now would wipe out the junior tranche

InvalidSolution

The provided solution is not a valid one

NotInSubmissionPeriod

Attempted to solve a pool which is not in a submission period

InsufficientCurrency

Insufficient currency available for desired operation

RiskBufferViolated

Risk Buffer validation failed

NoNAV

The NAV was not available

EpochNotExecutedYet

Epoch needs to be executed before you can collect

CannotAddOrRemoveTranches

Adding & removing tranches is not supported

InvalidTrancheSeniority

Invalid tranche seniority value

• seniority MUST be smaller number of tranches
• MUST be increasing per tranche

InvalidTrancheUpdate

Pre-requirements for a TrancheUpdate are not met for example: Tranche changed but not its metadata or vice versa

MetadataForCurrencyNotFound

No metadata for the given currency found

TrancheTokenNameTooLong

The given tranche token name exceeds the length limit

TrancheSymbolNameTooLong

The given tranche symbol name exceeds the length limit

FailedToRegisterTrancheMetadata

Registering the metadata for a tranche threw an error

FailedToUpdateTrancheMetadata

Updating the metadata for a tranche threw an error

InvalidTrancheId

Invalid TrancheId passed. In most cases out-of-bound index

TooManyTranches

The requested tranche configuration has too many tranches

NotNewBestSubmission

Submitted solution is not an improvement

NoSolutionAvailable

No solution has yet been provided for the epoch

PoolParameterBoundViolated

One of the runtime-level pool parameter bounds was violated

NoScheduledUpdate

No update for the pool is scheduled

ScheduledTimeHasNotPassed

Scheduled time for this update is in the future

UpdatePrerequesitesNotFulfilled

Update cannot be fulfilled yet

InvalidCurrency

A user has tried to create a pool with an invalid currency

ChangeNotFound

The external change was not found for the specified ChangeId.

ChangeNotReady

The external change was found for is not ready yet to be released.

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>