Enum casper_types::api_error::ApiError

source · [−]

pub enum ApiError {
Show 44 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,
    ExceededRecursionDepth,
    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);

`ExceededRecursionDepth`

Exceeded a recursion depth limit.

assert_eq!(ApiError::from(39), ApiError::ExceededRecursionDepth);

`AuctionError(u8)`

Tuple Fields

0: 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)));
}

`ContractHeader(u8)`

Tuple Fields

0: u8

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

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

`Mint(u8)`

Tuple Fields

0: 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)));
}

`HandlePayment(u8)`

Tuple Fields

0: 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)));
}

`User(u16)`

Tuple Fields

0: 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(_)));
}

Enum casper_types::api_error::ApiError

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

ExceededRecursionDepth

AuctionError(u8)

Tuple Fields

ContractHeader(u8)

Tuple Fields

Mint(u8)

Tuple Fields

HandlePayment(u8)

Tuple Fields

User(u16)

Tuple Fields

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

`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`

`ExceededRecursionDepth`

`AuctionError(u8)`

`ContractHeader(u8)`

`Mint(u8)`

`HandlePayment(u8)`

`User(u16)`

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,