Struct frame_system::CheckWeight

pub struct CheckWeight<T: Config + Send + Sync>(_);

Block resource (weight) limit check.

Transaction Validity

This extension does not influence any fields of TransactionValidity in case the transaction is valid.

Implementations

impl<T: Config + Send + Sync> CheckWeight<T>where
    T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

pub fn new() -> Self

Creates new SignedExtension to check weight of the extrinsic.

pub fn do_pre_dispatch(
    info: &DispatchInfoOf<T::RuntimeCall>,
    len: usize
) -> Result<(), TransactionValidityError>

Do the pre-dispatch checks. This can be applied to both signed and unsigned.

It checks and notes the new weight and length.

Examples found in repository

src/extensions/check_weight.rs (line 193)

	fn pre_dispatch(
		self,
		_who: &Self::AccountId,
		_call: &Self::Call,
		info: &DispatchInfoOf<Self::Call>,
		len: usize,
	) -> Result<(), TransactionValidityError> {
		Self::do_pre_dispatch(info, len)
	}

	fn validate(
		&self,
		_who: &Self::AccountId,
		_call: &Self::Call,
		info: &DispatchInfoOf<Self::Call>,
		len: usize,
	) -> TransactionValidity {
		Self::do_validate(info, len)
	}

	fn pre_dispatch_unsigned(
		_call: &Self::Call,
		info: &DispatchInfoOf<Self::Call>,
		len: usize,
	) -> Result<(), TransactionValidityError> {
		Self::do_pre_dispatch(info, len)
	}

pub fn do_validate(
    info: &DispatchInfoOf<T::RuntimeCall>,
    len: usize
) -> TransactionValidity

Do the validate checks. This can be applied to both signed and unsigned.

It only checks that the block weight and length limit will not exceed.

Examples found in repository

src/extensions/check_weight.rs (line 203)

	fn validate(
		&self,
		_who: &Self::AccountId,
		_call: &Self::Call,
		info: &DispatchInfoOf<Self::Call>,
		len: usize,
	) -> TransactionValidity {
		Self::do_validate(info, len)
	}

	fn pre_dispatch_unsigned(
		_call: &Self::Call,
		info: &DispatchInfoOf<Self::Call>,
		len: usize,
	) -> Result<(), TransactionValidityError> {
		Self::do_pre_dispatch(info, len)
	}

	fn validate_unsigned(
		_call: &Self::Call,
		info: &DispatchInfoOf<Self::Call>,
		len: usize,
	) -> TransactionValidity {
		Self::do_validate(info, len)
	}

Trait Implementations

impl<T: Clone + Config + Send + Sync> Clone for CheckWeight<T>

fn clone(&self) -> CheckWeight<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Config + Send + Sync> Debug for CheckWeight<T>

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

Formats the value using the given formatter.

impl<T: Config + Send + Sync> Decode for CheckWeight<T>where
    PhantomData<T>: Decode,

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

Attempt to deserialise the value from input.

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: Default + Config + Send + Sync> Default for CheckWeight<T>

fn default() -> CheckWeight<T>

Returns the “default value” for a type.

impl<T: Config + Send + Sync> Encode for CheckWeight<T>where
    PhantomData<T>: Encode,

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: FnOnce(&[u8]) -> R>(&self, f: F) -> R

Convert self to a slice and then invoke the given closure with it.

fn size_hint(&self) -> usize

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

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: PartialEq + Config + Send + Sync> PartialEq<CheckWeight<T>> for CheckWeight<T>

fn eq(&self, other: &CheckWeight<T>) -> 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: Config + Send + Sync> SignedExtension for CheckWeight<T>where
    T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

type AccountId = <T as Config>::AccountId

The type which encodes the sender identity.

type Call = <T as Config>::RuntimeCall

The type which encodes the call to be dispatched.

type AdditionalSigned = ()

Any additional data that will go into the signed payload. This may be created dynamically from the transaction using the additional_signed function.

type Pre = ()

The type that encodes information that can be passed from pre_dispatch to post-dispatch.

const IDENTIFIER: &'static str = "CheckWeight"

Unique identifier of this signed extension.

fn additional_signed(&self) -> Result<(), TransactionValidityError>

Construct any additional data that should be in the signed payload of the transaction. Can also perform any pre-signature-verification checks and return an error if needed.

fn pre_dispatch(
    self,
    _who: &Self::AccountId,
    _call: &Self::Call,
    info: &DispatchInfoOf<Self::Call>,
    len: usize
) -> Result<(), TransactionValidityError>

Do any pre-flight stuff for a signed transaction.

fn validate(
    &self,
    _who: &Self::AccountId,
    _call: &Self::Call,
    info: &DispatchInfoOf<Self::Call>,
    len: usize
) -> TransactionValidity

Validate a signed transaction for the transaction queue.

fn pre_dispatch_unsigned(
    _call: &Self::Call,
    info: &DispatchInfoOf<Self::Call>,
    len: usize
) -> Result<(), TransactionValidityError>

Do any pre-flight stuff for a unsigned transaction.

fn validate_unsigned(
    _call: &Self::Call,
    info: &DispatchInfoOf<Self::Call>,
    len: usize
) -> TransactionValidity

Validate an unsigned transaction for the transaction queue.

fn post_dispatch(
    _pre: Option<Self::Pre>,
    info: &DispatchInfoOf<Self::Call>,
    post_info: &PostDispatchInfoOf<Self::Call>,
    _len: usize,
    _result: &DispatchResult
) -> Result<(), TransactionValidityError>

Do any post-flight stuff for an extrinsic.

fn metadata() -> Vec<SignedExtensionMetadata, Global>

Returns the metadata for this signed extension.

impl<T> TypeInfo for CheckWeight<T>where
    PhantomData<T>: TypeInfo + 'static,
    T: Config + Send + Sync + 'static,

type Identity = CheckWeight<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config + Send + Sync> EncodeLike<CheckWeight<T>> for CheckWeight<T>where
    PhantomData<T>: Encode,

impl<T: Eq + Config + Send + Sync> Eq for CheckWeight<T>

impl<T: Config + Send + Sync> StructuralEq for CheckWeight<T>

impl<T: Config + Send + Sync> StructuralPartialEq for CheckWeight<T>