Enum frame_support::weights::SimpleDispatchInfo

pub enum SimpleDispatchInfo {
    FixedNormal(Weight),
    MaxNormal,
    InsecureFreeNormal,
    FixedOperational(Weight),
    MaxOperational,
    FixedMandatory(Weight),
}

Default type used with the #[weight = x] attribute in a substrate chain.

A user may pass in any other type that implements the correct traits. If not, the Default implementation of SimpleDispatchInfo is used.

For each generalized group (Normal and Operation):

• A Fixed variant means weight fee is charged normally and the weight is the number specified in the inner value of the variant.
• A Free variant is equal to ::Fixed(0). Note that this does not guarantee inclusion.
• A Max variant is equal to ::Fixed(Weight::max_value()).

As for the generalized groups themselves:

• Normal variants will be assigned a priority proportional to their weight. They can only consume a portion (defined in the system module) of the maximum block resource limits.
• Operational variants will be assigned the maximum priority. They can potentially consume the entire block resource limit.

Variants

FixedNormal(Weight)

A normal dispatch with fixed weight.

MaxNormal

A normal dispatch with the maximum weight.

InsecureFreeNormal

A normal dispatch with no weight. Base and bytes fees still need to be paid.

FixedOperational(Weight)

An operational dispatch with fixed weight.

MaxOperational

An operational dispatch with the maximum weight.

FixedMandatory(Weight)

A mandatory dispatch with fixed weight.

NOTE: Signed transactions may not (directly) dispatch this kind of a call, so the other attributes concerning transactability (e.g. priority, fee paying) are moot.

Methods

impl SimpleDispatchInfo

pub fn zero() -> Self

An additive zero variant of SimpleDispatchInfo.

Trait Implementations

impl<T> ClassifyDispatch<T> for SimpleDispatchInfo

fn classify_dispatch(&self, _: T) -> DispatchClass

Classify the dispatch function based on input data target of type T. When implementing this for a dispatchable, T will be a tuple of all arguments given to the function (except origin).

impl Clone for SimpleDispatchInfo

fn clone(&self) -> SimpleDispatchInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for SimpleDispatchInfo

impl Default for SimpleDispatchInfo

fn default() -> Self

Returns the "default value" for a type.

impl From<SimpleDispatchInfo> for DispatchClass

fn from(tx: SimpleDispatchInfo) -> Self

Performs the conversion.

impl<T> PaysFee<T> for SimpleDispatchInfo

fn pays_fee(&self, _: T) -> bool

impl<T> WeighData<T> for SimpleDispatchInfo

fn weigh_data(&self, _: T) -> Weight

Weigh the data T given by target. When implementing this for a dispatchable, T will be a tuple of all arguments given to the function (except origin).