Enum near_primitives::errors::InvalidTxError

pub enum InvalidTxError {
    InvalidAccessKeyError(InvalidAccessKeyError),
    InvalidSignerId {
        signer_id: String,
    },
    SignerDoesNotExist {
        signer_id: AccountId,
    },
    InvalidNonce {
        tx_nonce: Nonce,
        ak_nonce: Nonce,
    },
    NonceTooLarge {
        tx_nonce: Nonce,
        upper_bound: Nonce,
    },
    InvalidReceiverId {
        receiver_id: String,
    },
    InvalidSignature,
    NotEnoughBalance {
        signer_id: AccountId,
        balance: Balance,
        cost: Balance,
    },
    LackBalanceForState {
        signer_id: AccountId,
        amount: Balance,
    },
    CostOverflow,
    InvalidChain,
    Expired,
    ActionsValidation(ActionsValidationError),
    TransactionSizeExceeded {
        size: u64,
        limit: u64,
    },
}

An error happened during TX execution

Variants

InvalidAccessKeyError(InvalidAccessKeyError)

Tuple Fields

0: InvalidAccessKeyError

Happens if a wrong AccessKey used or AccessKey has not enough permissions

InvalidSignerId

Fields

signer_id: String

TX signer_id is not a valid AccountId

SignerDoesNotExist

Fields

signer_id: AccountId

TX signer_id is not found in a storage

InvalidNonce

Fields

tx_nonce: Nonce

ak_nonce: Nonce

Transaction nonce must be account[access_key].nonce + 1.

NonceTooLarge

Fields

tx_nonce: Nonce

upper_bound: Nonce

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

InvalidReceiverId

Fields

receiver_id: String

TX receiver_id is not a valid AccountId

InvalidSignature

TX signature is not valid

NotEnoughBalance

Fields

signer_id: AccountId

balance: Balance

cost: Balance

Account does not have enough balance to cover TX cost

LackBalanceForState

Fields

signer_id: AccountId

An account which doesn’t have enough balance to cover storage.

amount: Balance

Required balance to cover the state.

Signer account doesn’t have enough balance after transaction.

CostOverflow

An integer overflow occurred during transaction cost estimation.

InvalidChain

Transaction parent block hash doesn’t belong to the current chain

Expired

Transaction has expired

ActionsValidation(ActionsValidationError)

Tuple Fields

0: ActionsValidationError

An error occurred while validating actions of a Transaction.

TransactionSizeExceeded

Fields

size: u64

limit: u64

The size of serialized transaction exceeded the limit.

Trait Implementations

impl BorshDeserialize for InvalidTxError where
    InvalidAccessKeyError: BorshDeserialize,
    String: BorshDeserialize,
    AccountId: BorshDeserialize,
    Nonce: BorshDeserialize,
    Nonce: BorshDeserialize,
    Nonce: BorshDeserialize,
    Nonce: BorshDeserialize,
    String: BorshDeserialize,
    AccountId: BorshDeserialize,
    Balance: BorshDeserialize,
    Balance: BorshDeserialize,
    AccountId: BorshDeserialize,
    Balance: BorshDeserialize,
    ActionsValidationError: BorshDeserialize,
    u64: BorshDeserialize,
    u64: 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 InvalidTxError where
    InvalidAccessKeyError: BorshSerialize,
    String: BorshSerialize,
    AccountId: BorshSerialize,
    Nonce: BorshSerialize,
    Nonce: BorshSerialize,
    Nonce: BorshSerialize,
    Nonce: BorshSerialize,
    String: BorshSerialize,
    AccountId: BorshSerialize,
    Balance: BorshSerialize,
    Balance: BorshSerialize,
    AccountId: BorshSerialize,
    Balance: BorshSerialize,
    ActionsValidationError: BorshSerialize,
    u64: BorshSerialize,
    u64: 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 InvalidTxError

fn clone(&self) -> InvalidTxError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InvalidTxError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InvalidTxError

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

Deserialize this value from the given Serde deserializer.

impl Display for InvalidTxError

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

Formats the value using the given formatter.

impl From<IntegerOverflowError> for InvalidTxError

fn from(_: IntegerOverflowError) -> Self

Performs the conversion.

impl From<InvalidAccessKeyError> for InvalidTxError

fn from(error: InvalidAccessKeyError) -> Self

Performs the conversion.

impl From<InvalidTxError> for TxExecutionError

fn from(error: InvalidTxError) -> Self

Performs the conversion.

impl From<InvalidTxError> for RuntimeError

fn from(e: InvalidTxError) -> Self

Performs the conversion.

impl PartialEq<InvalidTxError> for InvalidTxError

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

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

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

This method tests for !=.

impl Serialize for InvalidTxError

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 InvalidTxError

impl StructuralEq for InvalidTxError

impl StructuralPartialEq for InvalidTxError