Enum frame_support::pallet_prelude::InvalidTransaction

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

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).

Possible causes

When using a signed extension that provides additional data for signing, it is required that the signing and the verifying side use the same additional data. Additional data will only be used to generate the signature, but will not be part of the transaction itself. As the verifying side does not know which additional data was used while signing it will only be able to assume a bad signature and cannot express a more meaningful error.

AncientBirthBlock

The transaction birth block is ancient.

Possible causes

For FRAME-based runtimes this would be caused by `current block number

• Era::birth block number > BlockHashCount. (e.g. in Polkadot BlockHashCount` = 2400, so a transaction with birth block number 1337 would be valid up until block number 1337 + 2400, after which point the transaction would be considered to have an ancient birth block.)

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.

BadMandatory

An extrinsic with a Mandatory dispatch resulted in Error. This is indicative of either a malicious validator or a buggy provide_inherent. In any case, it can result in dangerously overweight blocks and therefore if found, invalidates the block.

MandatoryDispatch

A transaction with a mandatory dispatch. This is invalid; only inherent extrinsics are allowed to have mandatory dispatches.

Implementations

impl InvalidTransaction

pub fn exhausted_resources(&self) -> bool

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

pub fn was_mandatory(&self) -> bool

Returns if the reason for the invalidity was a mandatory call failing.

Trait Implementations

impl Clone for InvalidTransaction

pub fn clone(&self) -> InvalidTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for InvalidTransaction

impl Debug for InvalidTransaction

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

Formats the value using the given formatter.

impl Decode for InvalidTransaction

pub fn decode<__CodecInputEdqy>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<InvalidTransaction, Error> where
    __CodecInputEdqy: Input, 

Attempt to deserialise the value from input.

pub fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

pub fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for InvalidTransaction

pub fn encode_to<__CodecOutputEdqy>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
) where
    __CodecOutputEdqy: Output + ?Sized, 

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

pub fn size_hint(&self) -> usize

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

pub fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

pub 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.

pub fn encoded_size(&self) -> usize

Calculates the encoded size.

impl EncodeLike<InvalidTransaction> for InvalidTransaction

impl Eq for InvalidTransaction

impl From<InvalidTransaction> for TransactionValidityError

pub fn from(err: InvalidTransaction) -> TransactionValidityError

Performs the conversion.

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

pub fn into(self) -> Result<ValidTransaction, TransactionValidityError>

Performs the conversion.

impl PartialEq<InvalidTransaction> for InvalidTransaction

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

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

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

This method tests for !=.

impl Serialize for InvalidTransaction

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

Serialize this value into the given Serde serializer.

impl StructuralEq for InvalidTransaction

impl StructuralPartialEq for InvalidTransaction