Enum casper_types::ApiError[−][src]

pub enum ApiError {
Show 43 variants    None,
    MissingArgument,
    InvalidArgument,
    Deserialize,
    Read,
    ValueNotFound,
    ContractNotFound,
    GetKey,
    UnexpectedKeyVariant,
    UnexpectedContractRefVariant,
    InvalidPurseName,
    InvalidPurse,
    UpgradeContractAtURef,
    Transfer,
    NoAccessRights,
    CLTypeMismatch,
    EarlyEndOfStream,
    Formatting,
    LeftOverBytes,
    OutOfMemory,
    MaxKeysLimit,
    DuplicateKey,
    PermissionDenied,
    MissingKey,
    ThresholdViolation,
    KeyManagementThreshold,
    DeploymentThreshold,
    InsufficientTotalWeight,
    InvalidSystemContract,
    PurseNotCreated,
    Unhandled,
    BufferTooSmall,
    HostBufferEmpty,
    HostBufferFull,
    AllocLayout,
    DictionaryItemKeyExceedsLength,
    InvalidDictionaryItemKey,
    MissingSystemContractHash,
    AuctionError(u8),
    ContractHeader(u8),
    Mint(u8),
    HandlePayment(u8),
    User(u16),
}

Expand description

Errors which can be encountered while running a smart contract.

An ApiError can be converted to a u32 in order to be passed via the execution engine’s ext_ffi::casper_revert() function. This means the information each variant can convey is limited.

The variants are split into numeric ranges as follows:

Inclusive range	Variant(s)
[1, 64511]	all except reserved system contract error ranges defined below.
[64512, 64767]	`Auction`
[64768, 65023]	`ContractHeader`
[65024, 65279]	`Mint`
[65280, 65535]	`HandlePayment`
[65536, 131071]	`User`

Users can specify a C-style enum and implement From to ease usage of casper_contract::runtime::revert(), e.g.

use casper_types::ApiError;

#[repr(u16)]
enum FailureCode {
    Zero = 0,  // 65,536 as an ApiError::User
    One,       // 65,537 as an ApiError::User
    Two        // 65,538 as an ApiError::User
}

impl From<FailureCode> for ApiError {
    fn from(code: FailureCode) -> Self {
        ApiError::User(code as u16)
    }
}

assert_eq!(ApiError::User(1), FailureCode::One.into());
assert_eq!(65_536, u32::from(ApiError::from(FailureCode::Zero)));
assert_eq!(65_538, u32::from(ApiError::from(FailureCode::Two)));

Variants

None

Optional data was unexpectedly None.

assert_eq!(ApiError::from(1), ApiError::None);

MissingArgument

Specified argument not provided.

assert_eq!(ApiError::from(2), ApiError::MissingArgument);

InvalidArgument

Argument not of correct type.

assert_eq!(ApiError::from(3), ApiError::InvalidArgument);

Deserialize

Failed to deserialize a value.

assert_eq!(ApiError::from(4), ApiError::Deserialize);

Read

casper_contract::storage::read() returned an error.

assert_eq!(ApiError::from(5), ApiError::Read);

ValueNotFound

The given key returned a None value.

assert_eq!(ApiError::from(6), ApiError::ValueNotFound);

ContractNotFound

Failed to find a specified contract.

assert_eq!(ApiError::from(7), ApiError::ContractNotFound);

GetKey

A call to casper_contract::runtime::get_key() returned a failure.

assert_eq!(ApiError::from(8), ApiError::GetKey);

UnexpectedKeyVariant

The Key variant was not as expected.

assert_eq!(ApiError::from(9), ApiError::UnexpectedKeyVariant);

UnexpectedContractRefVariant

Obsolete error variant (we no longer have ContractRef).

assert_eq!(ApiError::from(10), ApiError::UnexpectedContractRefVariant);

InvalidPurseName

Invalid purse name given.

assert_eq!(ApiError::from(11), ApiError::InvalidPurseName);

InvalidPurse

Invalid purse retrieved.

assert_eq!(ApiError::from(12), ApiError::InvalidPurse);

UpgradeContractAtURef

Failed to upgrade contract at URef.

assert_eq!(ApiError::from(13), ApiError::UpgradeContractAtURef);

Transfer

Failed to transfer motes.

assert_eq!(ApiError::from(14), ApiError::Transfer);

NoAccessRights

The given URef has no access rights.

assert_eq!(ApiError::from(15), ApiError::NoAccessRights);

CLTypeMismatch

A given type could not be constructed from a CLValue.

assert_eq!(ApiError::from(16), ApiError::CLTypeMismatch);

EarlyEndOfStream

Early end of stream while deserializing.

assert_eq!(ApiError::from(17), ApiError::EarlyEndOfStream);

Formatting

Formatting error while deserializing.

assert_eq!(ApiError::from(18), ApiError::Formatting);

LeftOverBytes

Not all input bytes were consumed in deserialize.

assert_eq!(ApiError::from(19), ApiError::LeftOverBytes);

OutOfMemory

Out of memory error.

assert_eq!(ApiError::from(20), ApiError::OutOfMemory);

MaxKeysLimit

There are already maximum AccountHashs associated with the given account.

assert_eq!(ApiError::from(21), ApiError::MaxKeysLimit);

DuplicateKey

The given AccountHash is already associated with the given account.

assert_eq!(ApiError::from(22), ApiError::DuplicateKey);

PermissionDenied

Caller doesn’t have sufficient permissions to perform the given action.

assert_eq!(ApiError::from(23), ApiError::PermissionDenied);

MissingKey

The given AccountHash is not associated with the given account.

assert_eq!(ApiError::from(24), ApiError::MissingKey);

ThresholdViolation

Removing/updating the given associated AccountHash would cause the total Weight of all remaining AccountHashs to fall below one of the action thresholds for the given account.

assert_eq!(ApiError::from(25), ApiError::ThresholdViolation);

KeyManagementThreshold

Setting the key-management threshold to a value lower than the deployment threshold is disallowed.

assert_eq!(ApiError::from(26), ApiError::KeyManagementThreshold);

DeploymentThreshold

Setting the deployment threshold to a value greater than any other threshold is disallowed.

assert_eq!(ApiError::from(27), ApiError::DeploymentThreshold);

InsufficientTotalWeight

Setting a threshold to a value greater than the total weight of associated keys is disallowed.

assert_eq!(ApiError::from(28), ApiError::InsufficientTotalWeight);

InvalidSystemContract

The given u32 doesn’t map to a SystemContractType.

assert_eq!(ApiError::from(29), ApiError::InvalidSystemContract);

PurseNotCreated

Failed to create a new purse.

assert_eq!(ApiError::from(30), ApiError::PurseNotCreated);

Unhandled

An unhandled value, likely representing a bug in the code.

assert_eq!(ApiError::from(31), ApiError::Unhandled);

BufferTooSmall

The provided buffer is too small to complete an operation.

assert_eq!(ApiError::from(32), ApiError::BufferTooSmall);

HostBufferEmpty

No data available in the host buffer.

assert_eq!(ApiError::from(33), ApiError::HostBufferEmpty);

HostBufferFull

The host buffer has been set to a value and should be consumed first by a read operation.

assert_eq!(ApiError::from(34), ApiError::HostBufferFull);

AllocLayout

Could not lay out an array in memory

assert_eq!(ApiError::from(35), ApiError::AllocLayout);

DictionaryItemKeyExceedsLength

The dictionary_item_key length exceeds the maximum length.

assert_eq!(ApiError::from(36), ApiError::DictionaryItemKeyExceedsLength);

InvalidDictionaryItemKey

The dictionary_item_key is invalid.

assert_eq!(ApiError::from(37), ApiError::InvalidDictionaryItemKey);

MissingSystemContractHash

Unable to retrieve the requested system contract hash.

assert_eq!(ApiError::from(38), ApiError::MissingSystemContractHash);

AuctionError(u8)

Error specific to Auction contract. See casper_types::system::auction::Error.

for code in 64512..=64767 {
    assert!(matches!(ApiError::from(code), ApiError::AuctionError(_auction_error)));
}

Tuple Fields of AuctionError

0: u8

ContractHeader(u8)

Contract header errors. See casper_types::contracts::Error.

for code in 64768..=65023 {
    assert!(matches!(ApiError::from(code), ApiError::ContractHeader(_contract_header_error)));
}

Tuple Fields of ContractHeader

0: u8

Mint(u8)

Error specific to Mint contract. See casper_types::system::mint::Error.

for code in 65024..=65279 {
    assert!(matches!(ApiError::from(code), ApiError::Mint(_mint_error)));
}

Tuple Fields of Mint

0: u8

HandlePayment(u8)

Error specific to Handle Payment contract. See casper_types::system::handle_payment.

for code in 65280..=65535 {
    assert!(matches!(ApiError::from(code), ApiError::HandlePayment(_handle_payment_error)));
}

Tuple Fields of HandlePayment

0: u8

User(u16)

User-specified error code. The internal u16 value is added to u16::MAX as u32 + 1 when an Error::User is converted to a u32.

for code in 65536..131071 {
    assert!(matches!(ApiError::from(code), ApiError::User(_)));
}

Tuple Fields of User

0: u16

Enum casper_types::ApiError[−][src]

Variants

Tuple Fields of AuctionError

Tuple Fields of ContractHeader

Tuple Fields of Mint

Tuple Fields of HandlePayment

Tuple Fields of User

Trait Implementations

impl Clone for ApiError

fn clone(&self) -> ApiError

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

impl Debug for ApiError

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

impl Display for ApiError

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

impl From<AddKeyFailure> for ApiError

fn from(error: AddKeyFailure) -> Self

impl From<ApiError> for u32

fn from(error: ApiError) -> Self

impl From<CLValueError> for ApiError

fn from(error: CLValueError) -> Self

impl From<Error> for ApiError

fn from(error: Error) -> Self

impl From<Error> for ApiError

fn from(error: Error) -> Self

impl From<Error> for ApiError

fn from(error: Error) -> Self

impl From<Error> for ApiError

fn from(error: Error) -> Self

impl From<Error> for ApiError

fn from(error: Error) -> Self

impl From<RemoveKeyFailure> for ApiError

fn from(error: RemoveKeyFailure) -> Self

impl From<SetThresholdFailure> for ApiError

fn from(error: SetThresholdFailure) -> Self

impl From<TryFromSliceForAccountHashError> for ApiError

fn from(_error: TryFromSliceForAccountHashError) -> Self

impl From<UpdateKeyFailure> for ApiError

fn from(error: UpdateKeyFailure) -> Self

impl From<u32> for ApiError

fn from(value: u32) -> ApiError

impl PartialEq<ApiError> for ApiError

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

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

impl Copy for ApiError

impl Eq for ApiError

impl StructuralEq for ApiError

impl StructuralPartialEq for ApiError

Auto Trait Implementations

impl RefUnwindSafe for ApiError

impl Send for ApiError

impl Sync for ApiError

impl Unpin for ApiError

impl UnwindSafe for ApiError

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

impl<T> Pipe for T

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

impl<T> PipeAsRef for T

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn conv<T>(self) -> T where
Self: Into<T>,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T, U> Into<U> for T where
U: From<T>,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

impl<T, U> TapAsRef<U> for T where
U: ?Sized,

fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,

fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,

fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,

fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,

impl<T, U> TapBorrow<U> for T where
U: ?Sized,

fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,

fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,

fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,

fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,

fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,

fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,

fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,

fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,

impl<T> ToOwned for T where
T: Clone,

impl<T> ToString for T where
T: Display + ?Sized,

fn try_conv<T>(self) -> Result<T, Self::Error> where
Self: TryInto<T>,

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

impl<V, T> VZip<V> for T where
V: MultiLane<T>,