Enum pallet_glutton::pallet::Call

pub enum Call<T: Config> {
    initialize_pallet {
        new_count: u32,
        witness_count: Option<u32>,
    },
    set_compute {
        compute: FixedU64,
    },
    set_storage {
        storage: FixedU64,
    },
    bloat {
        garbage: Vec<[u8; 1024]>,
    },
    set_block_length {
        block_length: FixedU64,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

initialize_pallet

Initialize the pallet. Should be called once, if no genesis state was provided.

current_count is the current number of elements in TrashData. This can be set to None when the pallet is first initialized.

Only callable by Root or AdminOrigin. A good default for new_count is 5_000.

Fields

new_count: u32

witness_count: Option<u32>

set_compute

Set how much of the remaining ref_time weight should be consumed by on_idle.

Only callable by Root or AdminOrigin.

Fields

compute: FixedU64

set_storage

Set how much of the remaining proof_size weight should be consumed by on_idle.

1.0 means that all remaining proof_size will be consumed. The PoV benchmarking results that are used here are likely an over-estimation. 100% intended consumption will therefore translate to less than 100% actual consumption.

Only callable by Root or AdminOrigin.

Fields

storage: FixedU64

bloat

Increase the block size by including the specified garbage bytes.

Fields

garbage: Vec<[u8; 1024]>

set_block_length

Set how much of the block length should be filled with trash data on each block.

1.0 means that all block should be filled. If set to 1.0, storage proof size will be close to zero.

Only callable by Root or AdminOrigin.

Fields

block_length: FixedU64

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_initialize_pallet( new_count: u32, witness_count: Option<u32>, ) -> Self

Create a call with the variant initialize_pallet.

pub fn new_call_variant_set_compute(compute: FixedU64) -> Self

Create a call with the variant set_compute.

pub fn new_call_variant_set_storage(storage: FixedU64) -> Self

Create a call with the variant set_storage.

pub fn new_call_variant_bloat(garbage: Vec<[u8; 1024]>) -> Self

Create a call with the variant bloat.

pub fn new_call_variant_set_block_length(block_length: FixedU64) -> Self

Create a call with the variant set_block_length.

Trait Implementations

impl<T: Config> CheckIfFeeless for Call<T>

type Origin = <T as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

impl<T: Config> Clone for Call<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Config> Debug for Call<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for Call<T>

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

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<T: Config> Encode for Call<T>

fn size_hint(&self) -> usize

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

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

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<T: Config> GetCallIndex for Call<T>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as [GetCallName].

impl<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

fn get_call_names() -> &'static [&'static str]

Return all function names in the same order as [GetCallIndex].

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config> PartialEq for Call<T>

fn eq(&self, other: &Self) -> 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<T> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> UnfilteredDispatchable for Call<T>

type RuntimeOrigin = <T as Config>::RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: Self::RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

impl<T: Config> EncodeLike for Call<T>

impl<T: Config> Eq for Call<T>