Enum Error

#[non_exhaustive]
#[repr(u8)]
pub enum Error {
    MissingKey = 0,
    InvalidKeyVariant = 1,
    MissingValue = 2,
    Serialization = 3,
    TransferToBidPurse = 4,
    InvalidAmount = 5,
    BidNotFound = 6,
    ValidatorNotFound = 7,
    DelegatorNotFound = 8,
    Storage = 9,
    Bonding = 10,
    Unbonding = 11,
    ReleaseFounderStake = 12,
    GetBalance = 13,
    InvalidContext = 14,
    ValidatorFundsLocked = 15,
    InvalidCaller = 16,
    InvalidPublicKey = 17,
    BondNotFound = 18,
    CreatePurseFailed = 19,
    UnbondTooLarge = 20,
    BondTooSmall = 21,
    MissingDelegations = 22,
    MismatchedEraValidators = 23,
    MintReward = 24,
    InvalidValidatorSlotsValue = 25,
    MintReduceTotalSupply = 26,
    TransferToDelegatorPurse = 27,
    ValidatorRewardTransfer = 28,
    DelegatorRewardTransfer = 29,
    WithdrawDelegatorReward = 30,
    WithdrawValidatorReward = 31,
    TransferToUnbondingPurse = 32,
    RecordEraInfo = 33,
    CLValue = 34,
    MissingSeigniorageRecipients = 35,
    Transfer = 36,
    DelegationRateTooLarge = 37,
    DelegatorFundsLocked = 38,
    ArithmeticOverflow = 39,
    GasLimit = 40,
    RuntimeStackOverflow = 41,
    MintError = 42,
    ExceededDelegatorSizeLimit = 43,
    GlobalDelegatorCapacityReached = 44,
    DelegationAmountTooSmall = 45,
    RuntimeStack = 46,
    AuctionBidsDisabled = 47,
    GetAccumulationPurse = 48,
    TransferToAdministrator = 49,
    ForgedReference = 50,
    MissingPurse = 51,
    ValidatorBidExistsAlready = 52,
    BridgeRecordChainTooLong = 53,
    UnexpectedBidVariant = 54,
    DelegationAmountTooLarge = 55,
    ReservationNotFound = 56,
    ExceededReservationSlotsLimit = 57,
    ExceededReservationsLimit = 58,
    ReservationSlotsCountTooSmall = 59,
    UnexpectedUnbondVariant = 60,
    UnexpectedStoredValueVariant = 61,
}

Errors which can occur while executing the Auction contract.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

MissingKey = 0

Unable to find named key in the contract’s named keys.

assert_eq!(0, Error::MissingKey as u8);

InvalidKeyVariant = 1

Invalid key variant.

assert_eq!(1, Error::InvalidKeyVariant as u8);

MissingValue = 2

Value under an uref does not exist. This means the installer contract didn’t work properly.

assert_eq!(2, Error::MissingValue as u8);

Serialization = 3

ABI serialization issue while reading or writing.

assert_eq!(3, Error::Serialization as u8);

TransferToBidPurse = 4

Triggered when contract was unable to transfer desired amount of tokens into a bid purse.

assert_eq!(4, Error::TransferToBidPurse as u8);

InvalidAmount = 5

User passed invalid amount of tokens which might result in wrong values after calculation.

assert_eq!(5, Error::InvalidAmount as u8);

BidNotFound = 6

Unable to find a bid by account hash in active_bids map.

assert_eq!(6, Error::BidNotFound as u8);

ValidatorNotFound = 7

Validator’s account hash was not found in the map.

assert_eq!(7, Error::ValidatorNotFound as u8);

DelegatorNotFound = 8

Delegator’s account hash was not found in the map.

assert_eq!(8, Error::DelegatorNotFound as u8);

Storage = 9

Storage problem.

assert_eq!(9, Error::Storage as u8);

Bonding = 10

Raised when system is unable to bond.

assert_eq!(10, Error::Bonding as u8);

Unbonding = 11

Raised when system is unable to unbond.

assert_eq!(11, Error::Unbonding as u8);

ReleaseFounderStake = 12

Raised when Mint contract is unable to release founder stake.

assert_eq!(12, Error::ReleaseFounderStake as u8);

GetBalance = 13

Raised when the system is unable to determine purse balance.

assert_eq!(13, Error::GetBalance as u8);

InvalidContext = 14

Raised when an entry point is called from invalid account context.

assert_eq!(14, Error::InvalidContext as u8);

ValidatorFundsLocked = 15

Raised whenever a validator’s funds are still locked in but an attempt to withdraw was made.

assert_eq!(15, Error::ValidatorFundsLocked as u8);

InvalidCaller = 16

Raised when caller is not the system account.

assert_eq!(16, Error::InvalidCaller as u8);

InvalidPublicKey = 17

Raised when function is supplied a public key that does match the caller’s or does not have an associated account.

assert_eq!(17, Error::InvalidPublicKey as u8);

BondNotFound = 18

Validator is not bonded.

assert_eq!(18, Error::BondNotFound as u8);

CreatePurseFailed = 19

Unable to create purse.

assert_eq!(19, Error::CreatePurseFailed as u8);

UnbondTooLarge = 20

Attempted to unbond an amount which was too large.

assert_eq!(20, Error::UnbondTooLarge as u8);

BondTooSmall = 21

Attempted to bond with a stake which was too small.

assert_eq!(21, Error::BondTooSmall as u8);

MissingDelegations = 22

Raised when rewards are to be distributed to delegators, but the validator has no delegations.

assert_eq!(22, Error::MissingDelegations as u8);

MismatchedEraValidators = 23

The validators returned by the consensus component should match current era validators when distributing rewards.

assert_eq!(23, Error::MismatchedEraValidators as u8);

MintReward = 24

Failed to mint reward tokens.

assert_eq!(24, Error::MintReward as u8);

InvalidValidatorSlotsValue = 25

Invalid number of validator slots.

assert_eq!(25, Error::InvalidValidatorSlotsValue as u8);

MintReduceTotalSupply = 26

Failed to reduce total supply.

assert_eq!(26, Error::MintReduceTotalSupply as u8);

TransferToDelegatorPurse = 27

Triggered when contract was unable to transfer desired amount of tokens into a delegators purse.

assert_eq!(27, Error::TransferToDelegatorPurse as u8);

ValidatorRewardTransfer = 28

Triggered when contract was unable to perform a transfer to distribute validators reward.

assert_eq!(28, Error::ValidatorRewardTransfer as u8);

DelegatorRewardTransfer = 29

Triggered when contract was unable to perform a transfer to distribute delegators rewards.

assert_eq!(29, Error::DelegatorRewardTransfer as u8);

WithdrawDelegatorReward = 30

Failed to transfer desired amount while withdrawing delegators reward.

assert_eq!(30, Error::WithdrawDelegatorReward as u8);

WithdrawValidatorReward = 31

Failed to transfer desired amount while withdrawing validators reward.

assert_eq!(31, Error::WithdrawValidatorReward as u8);

TransferToUnbondingPurse = 32

Failed to transfer desired amount into unbonding purse.

assert_eq!(32, Error::TransferToUnbondingPurse as u8);

RecordEraInfo = 33

Failed to record era info.

assert_eq!(33, Error::RecordEraInfo as u8);

CLValue = 34

Failed to create a crate::CLValue.

assert_eq!(34, Error::CLValue as u8);

MissingSeigniorageRecipients = 35

Missing seigniorage recipients for given era.

assert_eq!(35, Error::MissingSeigniorageRecipients as u8);

Transfer = 36

Failed to transfer funds.

assert_eq!(36, Error::Transfer as u8);

DelegationRateTooLarge = 37

Delegation rate exceeds rate.

assert_eq!(37, Error::DelegationRateTooLarge as u8);

DelegatorFundsLocked = 38

Raised whenever a delegator’s funds are still locked in but an attempt to undelegate was made.

assert_eq!(38, Error::DelegatorFundsLocked as u8);

ArithmeticOverflow = 39

An arithmetic overflow has occurred.

assert_eq!(39, Error::ArithmeticOverflow as u8);

GasLimit = 40

Execution exceeded the gas limit.

assert_eq!(40, Error::GasLimit as u8);

RuntimeStackOverflow = 41

Too many frames on the runtime stack.

assert_eq!(41, Error::RuntimeStackOverflow as u8);

MintError = 42

An error that is raised when there is an error in the mint contract that cannot be mapped to a specific auction error.

assert_eq!(42, Error::MintError as u8);

ExceededDelegatorSizeLimit = 43

The validator has exceeded the maximum amount of delegators allowed. NOTE: This variant is no longer in use.

assert_eq!(43, Error::ExceededDelegatorSizeLimit as u8);

GlobalDelegatorCapacityReached = 44

The global delegator capacity for the auction has been reached. NOTE: This variant is no longer in use.

assert_eq!(44, Error::GlobalDelegatorCapacityReached as u8);

DelegationAmountTooSmall = 45

The delegated amount is below the minimum allowed.

assert_eq!(45, Error::DelegationAmountTooSmall as u8);

RuntimeStack = 46

Runtime stack error.

assert_eq!(46, Error::RuntimeStack as u8);

AuctionBidsDisabled = 47

An error that is raised on private chain only when a disable_auction_bids flag is set to true.

assert_eq!(47, Error::AuctionBidsDisabled as u8);

GetAccumulationPurse = 48

Error getting accumulation purse.

assert_eq!(48, Error::GetAccumulationPurse as u8);

TransferToAdministrator = 49

Failed to transfer desired amount into administrators account.

assert_eq!(49, Error::TransferToAdministrator as u8);

ForgedReference = 50

Failed to transfer desired amount into administrators account.

assert_eq!(50, Error::ForgedReference as u8);

MissingPurse = 51

Unable to find purse.

assert_eq!(51, Error::MissingPurse as u8);

ValidatorBidExistsAlready = 52

Failed to transfer validator bid to new public key.

assert_eq!(52, Error::ValidatorBidExistsAlready as u8);

BridgeRecordChainTooLong = 53

Failed to look up current validator bid because it’s public key has been changed and bridge record chain is too long to follow.

assert_eq!(53, Error::BridgeRecordChainTooLong as u8);

UnexpectedBidVariant = 54

Unexpected bid variant.

assert_eq!(54, Error::UnexpectedBidVariant as u8);

DelegationAmountTooLarge = 55

The delegated amount is above the maximum allowed.

assert_eq!(55, Error::DelegationAmountTooLarge as u8);

ReservationNotFound = 56

Reservation was not found in the map.

assert_eq!(56, Error::ReservationNotFound as u8);

ExceededReservationSlotsLimit = 57

Validator exceeded allowed number of reserved delegator slots.

assert_eq!(57, Error::ExceededReservationSlotsLimit as u8);

ExceededReservationsLimit = 58

All reserved slots for validator are already occupied.

assert_eq!(58, Error::ExceededReservationsLimit as u8);

ReservationSlotsCountTooSmall = 59

Reserved slots count is less than number of existing reservations.

assert_eq!(59, Error::ReservationSlotsCountTooSmall as u8);

UnexpectedUnbondVariant = 60

Unexpected unbond variant.

assert_eq!(60, Error::UnexpectedUnbondVariant as u8);

UnexpectedStoredValueVariant = 61

Unexpected stored value variant.

assert_eq!(61, Error::UnexpectedStoredValueVariant as u8);

Trait Implementations

impl CLTyped for Error

fn cl_type() -> CLType

The CLType of Self.

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl From<Error> for ApiError

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(_: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(error: Error) -> Error

Converts to this type from the input type.

impl FromBytes for Error

fn from_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error>

Deserializes the slice into Self.

fn from_vec(bytes: Vec<u8>) -> Result<(Self, Vec<u8>), Error>

Deserializes the Vec<u8> into Self.

impl Ord for Error

fn cmp(&self, other: &Error) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Error

fn eq(&self, other: &Error) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Error

fn partial_cmp(&self, other: &Error) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToBytes for Error

fn to_bytes(&self) -> Result<Vec<u8>, Error>

Serializes &self to a Vec<u8>.

fn serialized_length(&self) -> usize

Returns the length of the Vec<u8> which would be returned from a successful call to to_bytes() or into_bytes(). The data is not actually serialized, so this call is relatively cheap.

fn into_bytes(self) -> Result<Vec<u8>, Error>

where Self: Sized,

Consumes self and serializes to a Vec<u8>.

fn write_bytes(&self, writer: &mut Vec<u8>) -> Result<(), Error>

Writes &self into a mutable writer.

impl Copy for Error

impl Eq for Error

impl StructuralPartialEq for Error