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: Box<PublicKey>,
    },
    AddKeyAlreadyExists {
        account_id: AccountId,
        public_key: Box<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(FunctionCallError),
    NewReceiptValidationError(ReceiptValidationError),
    OnlyImplicitAccountCreationAllowed {
        account_id: AccountId,
    },
    DeleteAccountWithLargeState {
        account_id: AccountId,
    },
    DelegateActionInvalidSignature,
    DelegateActionSenderDoesNotMatchTxReceiver {
        sender_id: AccountId,
        receiver_id: AccountId,
    },
    DelegateActionExpired,
    DelegateActionAccessKeyError(InvalidAccessKeyError),
    DelegateActionInvalidNonce {
        delegate_nonce: Nonce,
        ak_nonce: Nonce,
    },
    DelegateActionNonceTooLarge {
        delegate_nonce: Nonce,
        upper_bound: Nonce,
    },
    NonRefundableTransferToExistingAccount {
        account_id: AccountId,
    },
}

Variants

AccountAlreadyExists

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

Fields

account_id: AccountId

AccountDoesNotExist

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

Fields

account_id: AccountId

CreateAccountOnlyByRegistrar

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

Fields

account_id: AccountId

registrar_account_id: AccountId

predecessor_id: AccountId

CreateAccountNotAllowed

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

Fields

account_id: AccountId

predecessor_id: AccountId

ActorNoPermission

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

Fields

account_id: AccountId

actor_id: AccountId

DeleteKeyDoesNotExist

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

Fields

account_id: AccountId

public_key: Box<PublicKey>

AddKeyAlreadyExists

The public key is already used for an existing access key

Fields

account_id: AccountId

public_key: Box<PublicKey>

DeleteAccountStaking

Account is staking and can not be deleted

Fields

account_id: AccountId

LackBalanceForState

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

Fields

account_id: AccountId

An account which needs balance

amount: Balance

Balance required to complete an action.

TriesToUnstake

Account is not yet staked, but tries to unstake

Fields

account_id: AccountId

TriesToStake

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

Fields

account_id: AccountId

stake: Balance

locked: Balance

balance: Balance

InsufficientStake

Fields

account_id: AccountId

stake: Balance

minimum_stake: Balance

FunctionCallError(FunctionCallError)

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

Error occurs when a CreateAccount action is called on a NEAR-implicit or ETH-implicit account. See NEAR-implicit account creation NEP: https://github.com/nearprotocol/NEPs/pull/71. Also, see ETH-implicit account creation NEP: https://github.com/near/NEPs/issues/518.

TODO(#8598): This error is named very poorly. A better name would be OnlyNamedAccountCreationAllowed.

Fields

account_id: AccountId

DeleteAccountWithLargeState

Delete account whose state is large is temporarily banned.

Fields

account_id: AccountId

DelegateActionInvalidSignature

Signature does not match the provided actions and given signer public key.

DelegateActionSenderDoesNotMatchTxReceiver

Receiver of the transaction doesn’t match Sender of the delegate action

Fields

sender_id: AccountId

receiver_id: AccountId

DelegateActionExpired

Delegate action has expired. max_block_height is less than actual block height.

DelegateActionAccessKeyError(InvalidAccessKeyError)

The given public key doesn’t exist for Sender account

DelegateActionInvalidNonce

DelegateAction nonce must be greater sender[public_key].nonce

Fields

delegate_nonce: Nonce

ak_nonce: Nonce

DelegateActionNonceTooLarge

DelegateAction nonce is larger than the upper bound given by the block height

Fields

delegate_nonce: Nonce

upper_bound: Nonce

NonRefundableTransferToExistingAccount

Non-refundable storage transfer to an existing account is not allowed according to NEP-491.

Fields

account_id: AccountId

Trait Implementations

impl BorshDeserialize for ActionErrorKind

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

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.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for ActionErrorKind

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

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 EnumExt for ActionErrorKind

fn deserialize_variant<__R: Read>( reader: &mut __R, variant_tag: u8, ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.

impl From<ActionErrorKind> for ActionError

fn from(e: ActionErrorKind) -> ActionError

Converts to this type from the input type.

impl PartialEq for ActionErrorKind

fn eq(&self, other: &ActionErrorKind) -> 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 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 StructuralPartialEq for ActionErrorKind