Enum interlay_runtime_parachain::DispatchClass

pub enum DispatchClass {
    Normal,
    Operational,
    Mandatory,
}

A generalized group of dispatch types.

NOTE whenever upgrading the enum make sure to also update DispatchClass::all and DispatchClass::non_mandatory helper functions.

Variants

Normal

A normal dispatch.

Operational

An operational dispatch.

Mandatory

A mandatory dispatch. These kinds of dispatch are always included regardless of their weight, therefore it is critical that they are separately validated to ensure that a malicious validator cannot craft a valid but impossibly heavy block. Usually this just means ensuring that the extrinsic can only be included once and that it is always very light.

Do NOT use it for extrinsics that can be heavy.

The only real use case for this is inherent extrinsics that are required to execute in a block for the block to be valid, and it solves the issue in the case that the block initialization is sufficiently heavy to mean that those inherents do not fit into the block. Essentially, we assume that in these exceptional circumstances, it is better to allow an overweight block to be created than to not allow any block at all to be created.

Implementations

impl DispatchClass

pub fn all() -> &'static [DispatchClass]

Returns an array containing all dispatch classes.

pub fn non_mandatory() -> &'static [DispatchClass]

Returns an array of all dispatch classes except Mandatory.

Trait Implementations

impl Clone for DispatchClass

fn clone(&self) -> DispatchClass

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DispatchClass

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

Formats the value using the given formatter.

impl Decode for DispatchClass

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<DispatchClass, 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 Default for DispatchClass

fn default() -> DispatchClass

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DispatchClass

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

Deserialize this value from the given Serde deserializer.

impl Encode for DispatchClass

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, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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<'a> OneOrMany<DispatchClass> for &'a [DispatchClass]

type Iter = Cloned<Iter<'a, DispatchClass>>

The iterator type.

fn into_iter(self) -> <&'a [DispatchClass] as OneOrMany<DispatchClass>>::Iter

Convert this item into an iterator.

impl OneOrMany<DispatchClass> for DispatchClass

type Iter = Once<DispatchClass>

The iterator type.

fn into_iter(self) -> <DispatchClass as OneOrMany<DispatchClass>>::Iter

Convert this item into an iterator.

impl PartialEq<DispatchClass> for DispatchClass

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

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 DispatchClass

type Identity = DispatchClass

The type identifying for which type info is provided.

fn type_info() -> Type<MetaForm>

Returns the static type identifier for Self.

impl Copy for DispatchClass

impl EncodeLike<DispatchClass> for DispatchClass

impl Eq for DispatchClass

impl StructuralEq for DispatchClass

impl StructuralPartialEq for DispatchClass