Enum sp_runtime::transaction_validity::InvalidTransaction

pub enum InvalidTransaction {
    Call,
    Payment,
    Future,
    Stale,
    BadProof,
    AncientBirthBlock,
    ExhaustsResources,
    Custom(u8),
}

An invalid transaction validity.

Variants

Call

The call of the transaction is not expected.

Payment

General error to do with the inability to pay some fees (e.g. account balance too low).

Future

General error to do with the transaction not yet being valid (e.g. nonce too high).

Stale

General error to do with the transaction being outdated (e.g. nonce too low).

BadProof

General error to do with the transaction's proofs (e.g. signature).

AncientBirthBlock

The transaction birth block is ancient.

ExhaustsResources

The transaction would exhaust the resources of current block.

The transaction might be valid, but there are not enough resources left in the current block.

Custom(u8)

Any other custom invalid validity that is not covered by this enum.

Methods

impl InvalidTransaction

pub fn exhausted_resources(&self) -> bool

Returns if the reason for the invalidity was block resource exhaustion.

Trait Implementations

impl Clone for InvalidTransaction

fn clone(&self) -> InvalidTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for InvalidTransaction

impl Debug for InvalidTransaction

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Decode for InvalidTransaction

fn decode<DecIn: Input>(input: &mut DecIn) -> Result<Self, Error>

Attempt to deserialise the value from input.

impl Encode for InvalidTransaction

fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

impl EncodeLike<InvalidTransaction> for InvalidTransaction

impl Eq for InvalidTransaction

impl From<InvalidTransaction> for &'static str

fn from(invalid: InvalidTransaction) -> &'static str

Performs the conversion.

impl From<InvalidTransaction> for TransactionValidityError

fn from(err: InvalidTransaction) -> Self

Performs the conversion.

impl Into<Result<ValidTransaction, TransactionValidityError>> for InvalidTransaction

fn into(self) -> TransactionValidity

Performs the conversion.

impl PartialEq<InvalidTransaction> for InvalidTransaction

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

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

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

This method tests for !=.

impl Serialize for InvalidTransaction

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

Serialize this value into the given Serde serializer.

impl StructuralEq for InvalidTransaction

impl StructuralPartialEq for InvalidTransaction