Enum pallet_society::pallet::Error

pub enum Error<T, I = ()> {
    NotMember,
    AlreadyMember,
    Suspended,
    NotSuspended,
    NoPayout,
    AlreadyFounded,
    InsufficientPot,
    AlreadyVouching,
    NotVouchingOnBidder,
    Head,
    Founder,
    AlreadyBid,
    AlreadyCandidate,
    NotCandidate,
    MaxMembers,
    NotFounder,
    NotHead,
    NotApproved,
    NotRejected,
    Approved,
    Rejected,
    InProgress,
    TooEarly,
    Voted,
    Expired,
    NotBidder,
    NoDefender,
    NotGroup,
    AlreadyElevated,
    AlreadyPunished,
    InsufficientFunds,
    NoVotes,
    // some variants omitted
}

The Error enum of this pallet.

Variants

NotMember

User is not a member.

AlreadyMember

User is already a member.

Suspended

User is suspended.

NotSuspended

User is not suspended.

NoPayout

Nothing to payout.

AlreadyFounded

Society already founded.

InsufficientPot

Not enough in pot to accept candidate.

AlreadyVouching

Member is already vouching or banned from vouching again.

NotVouchingOnBidder

Member is not vouching.

Head

Cannot remove the head of the chain.

Founder

Cannot remove the founder.

AlreadyBid

User has already made a bid.

AlreadyCandidate

User is already a candidate.

NotCandidate

User is not a candidate.

MaxMembers

Too many members in the society.

NotFounder

The caller is not the founder.

NotHead

The caller is not the head.

NotApproved

The membership cannot be claimed as the candidate was not clearly approved.

NotRejected

The candidate cannot be kicked as the candidate was not clearly rejected.

Approved

The candidacy cannot be dropped as the candidate was clearly approved.

Rejected

The candidacy cannot be bestowed as the candidate was clearly rejected.

InProgress

The candidacy cannot be concluded as the voting is still in progress.

TooEarly

The candidacy cannot be pruned until a full additional intake period has passed.

Voted

The skeptic already voted.

Expired

The skeptic need not vote on candidates from expired rounds.

NotBidder

User is not a bidder.

NoDefender

There is no defender currently.

NotGroup

Group doesn’t exist.

AlreadyElevated

The member is already elevated to this rank.

AlreadyPunished

The skeptic has already been punished for this offence.

InsufficientFunds

Funds are insufficient to pay off society debts.

NoVotes

The candidate/defender has no stale votes to remove.

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 encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

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

fn size_hint(&self) -> usize

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

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