Enum frame_support::pallet_prelude::InvalidTransaction

pub enum InvalidTransaction {
    Call,
    Payment,
    Future,
    Stale,
    BadProof,
    AncientBirthBlock,
    ExhaustsResources,
    Custom(u8),
    BadMandatory,
    MandatoryValidation,
    BadSigner,
    IndeterminateImplicit,
    UnknownOrigin,
}

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.

MandatoryValidation

An extrinsic with a mandatory dispatch tried to be validated. This is invalid; only inherent extrinsics are allowed to have mandatory dispatches.

BadSigner

The sending address is disabled or known to be invalid.

IndeterminateImplicit

The implicit data was unable to be calculated.

UnknownOrigin

The transaction extension did not authorize any origin.

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

fn clone(&self) -> InvalidTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InvalidTransaction

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

Formats the value using the given formatter.

impl Decode for InvalidTransaction

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

where __CodecInputEdqy: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

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

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for InvalidTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for InvalidTransaction

fn size_hint(&self) -> usize

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

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.

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.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl From<InvalidTransaction> for &'static str

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

Converts to this type from the input type.

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

fn from( invalid_transaction: InvalidTransaction, ) -> Result<ValidTransaction, TransactionValidityError>

Converts to this type from the input type.

impl From<InvalidTransaction> for TransactionValidityError

fn from(err: InvalidTransaction) -> TransactionValidityError

Converts to this type from the input type.

impl PartialEq 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: &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 InvalidTransaction

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 TypeInfo for InvalidTransaction

type Identity = InvalidTransaction

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Copy for InvalidTransaction

impl EncodeLike for InvalidTransaction

impl Eq for InvalidTransaction

impl StructuralPartialEq for InvalidTransaction