Enum Error

#[non_exhaustive]
#[repr(u8)]
pub enum Error {
    InsufficientFunds = 0,
    SourceNotFound = 1,
    DestNotFound = 2,
    InvalidURef = 3,
    InvalidAccessRights = 4,
    InvalidNonEmptyPurseCreation = 5,
    Storage = 6,
    PurseNotFound = 7,
    MissingKey = 8,
    TotalSupplyNotFound = 9,
    RecordTransferFailure = 10,
    InvalidTotalSupplyReductionAttempt = 11,
    NewURef = 12,
    PutKey = 13,
    WriteDictionary = 14,
    CLValue = 15,
    Serialize = 16,
    EqualSourceAndTarget = 17,
    ArithmeticOverflow = 18,
    InvalidContext = 20,
    UnapprovedSpendingAmount = 21,
    DisabledUnrestrictedTransfers = 22,
    ForgedReference = 23,
    InconsistentBalances = 24,
    UnableToGetSystemRegistry = 25,
}

Errors which can occur while executing the Mint 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.

InsufficientFunds = 0

Insufficient funds to complete the transfer.

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

SourceNotFound = 1

Source purse not found.

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

DestNotFound = 2

Destination purse not found.

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

InvalidURef = 3

The given URef does not reference the account holder’s purse, or such a URef does not have the required AccessRights.

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

InvalidAccessRights = 4

The source purse is not writeable (see URef::is_writeable), or the destination purse is not addable (see URef::is_addable).

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

InvalidNonEmptyPurseCreation = 5

Tried to create a new purse with a non-zero initial balance.

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

Storage = 6

Failed to read from local or global storage.

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

PurseNotFound = 7

Purse not found while trying to get balance.

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

MissingKey = 8

Unable to obtain a key by its name.

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

TotalSupplyNotFound = 9

Total supply not found.

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

RecordTransferFailure = 10

Failed to record transfer.

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

InvalidTotalSupplyReductionAttempt = 11

Invalid attempt to reduce total supply.

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

NewURef = 12

Failed to create new uref.

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

PutKey = 13

Failed to put key.

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

WriteDictionary = 14

Failed to write to dictionary.

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

CLValue = 15

Failed to create a crate::CLValue.

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

Serialize = 16

Failed to serialize data.

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

EqualSourceAndTarget = 17

Source and target purse crate::URefs are equal.

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

ArithmeticOverflow = 18

An arithmetic overflow has occurred.

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

InvalidContext = 20

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

UnapprovedSpendingAmount = 21

Session code tried to transfer more CSPR than user approved.

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

DisabledUnrestrictedTransfers = 22

Failed to transfer tokens on a private chain.

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

ForgedReference = 23

Attempt to access a record using forged permissions.

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

InconsistentBalances = 24

Available balance can never be greater than total balance.

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

UnableToGetSystemRegistry = 25

Unable to get the system registry.

assert_eq!(25, Error::UnableToGetSystemRegistry 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 duplicate 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: 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 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 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