Enum near_primitives::errors::ActionErrorKind

pub enum ActionErrorKind {
    AccountAlreadyExists {
        account_id: AccountId,
    },
    AccountDoesNotExist {
        account_id: AccountId,
    },
    CreateAccountOnlyByRegistrar {
        account_id: AccountId,
        registrar_account_id: AccountId,
        predecessor_id: AccountId,
    },
    CreateAccountNotAllowed {
        account_id: AccountId,
        predecessor_id: AccountId,
    },
    ActorNoPermission {
        account_id: AccountId,
        actor_id: AccountId,
    },
    DeleteKeyDoesNotExist {
        account_id: AccountId,
        public_key: PublicKey,
    },
    AddKeyAlreadyExists {
        account_id: AccountId,
        public_key: PublicKey,
    },
    DeleteAccountStaking {
        account_id: AccountId,
    },
    LackBalanceForState {
        account_id: AccountId,
        amount: Balance,
    },
    TriesToUnstake {
        account_id: AccountId,
    },
    TriesToStake {
        account_id: AccountId,
        stake: Balance,
        locked: Balance,
        balance: Balance,
    },
    InsufficientStake {
        account_id: AccountId,
        stake: Balance,
        minimum_stake: Balance,
    },
    FunctionCallError(FunctionCallErrorSer),
    NewReceiptValidationError(ReceiptValidationError),
    OnlyImplicitAccountCreationAllowed {
        account_id: AccountId,
    },
    DeleteAccountWithLargeState {
        account_id: AccountId,
    },
}

Variants

AccountAlreadyExists

Fields

account_id: AccountId

Happens when CreateAccount action tries to create an account with account_id which is already exists in the storage

AccountDoesNotExist

Fields

account_id: AccountId

Happens when TX receiver_id doesn’t exist (but action is not Action::CreateAccount)

CreateAccountOnlyByRegistrar

Fields

account_id: AccountId

registrar_account_id: AccountId

predecessor_id: AccountId

A top-level account ID can only be created by registrar.

CreateAccountNotAllowed

Fields

account_id: AccountId

predecessor_id: AccountId

A newly created account must be under a namespace of the creator account

ActorNoPermission

Fields

account_id: AccountId

actor_id: AccountId

Administrative actions like DeployContract, Stake, AddKey, DeleteKey. can be proceed only if sender=receiver or the first TX action is a CreateAccount action

DeleteKeyDoesNotExist

Fields

account_id: AccountId

public_key: PublicKey

Account tries to remove an access key that doesn’t exist

AddKeyAlreadyExists

Fields

account_id: AccountId

public_key: PublicKey

The public key is already used for an existing access key

DeleteAccountStaking

Fields

account_id: AccountId

Account is staking and can not be deleted

LackBalanceForState

Fields

account_id: AccountId

An account which needs balance

amount: Balance

Balance required to complete an action.

ActionReceipt can’t be completed, because the remaining balance will not be enough to cover storage.

TriesToUnstake

Fields

account_id: AccountId

Account is not yet staked, but tries to unstake

TriesToStake

Fields

account_id: AccountId

stake: Balance

locked: Balance

balance: Balance

The account doesn’t have enough balance to increase the stake.

InsufficientStake

Fields

account_id: AccountId

stake: Balance

minimum_stake: Balance

FunctionCallError(FunctionCallErrorSer)

An error occurred during a FunctionCall Action, parameter is debug message.

NewReceiptValidationError(ReceiptValidationError)

Error occurs when a new ActionReceipt created by the FunctionCall action fails receipt validation.

OnlyImplicitAccountCreationAllowed

Fields

account_id: AccountId

Error occurs when a CreateAccount action is called on hex-characters account of length 64. See implicit account creation NEP: https://github.com/nearprotocol/NEPs/pull/71.

DeleteAccountWithLargeState

Fields

account_id: AccountId

Delete account whose state is large is temporarily banned.

Trait Implementations

impl BorshDeserialize for ActionErrorKindwhere
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    PublicKey: BorshDeserialize,
    AccountId: BorshDeserialize,
    PublicKey: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    Balance: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,
    Balance: BorshDeserialize,
    Balance: BorshDeserialize,
    Balance: BorshDeserialize,
    AccountId: BorshDeserialize,
    Balance: BorshDeserialize,
    Balance: BorshDeserialize,
    FunctionCallErrorSer: BorshDeserialize,
    ReceiptValidationError: BorshDeserialize,
    AccountId: BorshDeserialize,
    AccountId: BorshDeserialize,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for ActionErrorKindwhere
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    PublicKey: BorshSerialize,
    AccountId: BorshSerialize,
    PublicKey: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    Balance: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,
    Balance: BorshSerialize,
    Balance: BorshSerialize,
    Balance: BorshSerialize,
    AccountId: BorshSerialize,
    Balance: BorshSerialize,
    Balance: BorshSerialize,
    FunctionCallErrorSer: BorshSerialize,
    ReceiptValidationError: BorshSerialize,
    AccountId: BorshSerialize,
    AccountId: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

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

Serialize this instance into a vector of bytes.

impl Clone for ActionErrorKind

fn clone(&self) -> ActionErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ActionErrorKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActionErrorKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ActionErrorKind

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

Formats the value using the given formatter.

impl From<ActionErrorKind> for ActionError

fn from(e: ActionErrorKind) -> ActionError

Converts to this type from the input type.

impl PartialEq<ActionErrorKind> for ActionErrorKind

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ActionErrorKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ActionErrorKind

impl StructuralEq for ActionErrorKind

impl StructuralPartialEq for ActionErrorKind