Struct DynamicMaxBlockWeight 

pub struct DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32 = 10, const ALLOW_NORMAL: bool = true>(pub Inner, _);

Transaction extension that dynamically changes the max block weight.

With block bundling, parachains are running with block weights that may not allow certain transactions to be applied, e.g. a runtime upgrade. To ensure that these transactions can still be applied, this transaction extension can change the max block weight as required. There are multiple requirements for it to change the block weight:

1. Only the first block of a core is allowed to change its block weight.

2. Any inherent or any transaction up to MAX_TRANSACTION_TO_CONSIDER requires more block weight than the target extrinsic weight. Target extrinsic weight is the max weight for the respective extrinsic class. The priority to determine the target e weight is the following, we start checking if WeightsPerClass::max_extrinsic is set, after this WeightsPerClass::max_total and if both of these are None we fall back to the actual target block weight.

Because the node is tracking the wall clock time while building a block to abort block production if it takes too long, we do not allow any block to change the block weight. The node knows that the first block of a core may runs longer. So, the node allows this block to take up to 2s of wall clock time. 2s is the time each PoV gets on the relay chain for its validation or in other words the maximum core execution time. The extension sets the [CumulusDigestItem::UseFullCore] digest when the block should occupy the entire core.

Before dispatching an extrinsic the extension will check the requirements and set the appropriate BlockWeightMode. After the extrinsic has finished, the checks from before dispatching the extrinsic are repeated with the post dispatch weights. The BlockWeightMode is changed properly.

Note

The extension requires that any of the inner extensions sets the BlockWeight. Otherwise the weight tracking is not working properly. Normally this is done by CheckWeight.

Generic parameters

• Config: The Config trait of this pallet.

• Inner: The inner transaction extensions aka the other transaction extensions to be used by the runtime.

• TargetBlockRate: The target block rate the parachain should be running with. Or in other words, the number of blocks the parachain should produce in 6s(relay chain slot duration).

• MAX_TRANSACTION: The maximum number of transactions to consider before giving up to change the max block weight.

• ALLOW_NORMAL: Should transactions with a dispatch class Normal be allowed to change the max block weight?

Tuple Fields

0: Inner

Implementations

impl<T, S, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> DynamicMaxBlockWeight<T, S, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

pub fn new(s: S) -> Self

Create a new DynamicMaxBlockWeight instance.

Trait Implementations

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Clone for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Config, Inner: Debug, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Debug for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

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

Formats the value using the given formatter.

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Decode for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: Decode, PhantomData<(Config, TargetBlockRate)>: Decode,

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<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Default for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Encode for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: Encode, PhantomData<(Config, TargetBlockRate)>: Encode,

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<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> From<Inner> for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

fn from(s: Inner) -> Self

Converts to this type from the input type.

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> PartialEq for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: PartialEq,

fn eq(&self, __other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Config: Config + Send + Sync, Inner: TransactionExtension<Config::RuntimeCall>, TargetBlockRate: Get<u32> + Send + Sync + 'static, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> TransactionExtension<<Config as Config>::RuntimeCall> for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Config::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

const IDENTIFIER: &'static str = "DynamicMaxBlockWeight<Use `metadata()`!>"

Unique identifier of this signed extension.

type Implicit = <Inner as TransactionExtension<<Config as Config>::RuntimeCall>>::Implicit

Any additional data which was known at the time of transaction construction and can be useful in authenticating the transaction. This is determined dynamically in part from the on-chain environment using the implicit function and not directly contained in the transaction itself and therefore is considered “implicit”.

type Val = <Inner as TransactionExtension<<Config as Config>::RuntimeCall>>::Val

The type that encodes information that can be passed from validate to prepare.

type Pre = <Inner as TransactionExtension<<Config as Config>::RuntimeCall>>::Pre

The type that encodes information that can be passed from prepare to post_dispatch.

fn implicit(&self) -> Result<Self::Implicit, TransactionValidityError>

Determine any additional data which was known at the time of transaction construction and can be useful in authenticating the transaction. The expected usage of this is to include in any data which is signed and verified as part of transaction validation. Also perform any pre-signature-verification checks and return an error if needed.

fn metadata() -> Vec<TransactionExtensionMetadata>

Returns the metadata for this extension.

fn weight(&self, call: &Config::RuntimeCall) -> Weight

The weight consumed by executing this extension instance fully during transaction dispatch.

fn validate( &self, origin: Config::RuntimeOrigin, call: &Config::RuntimeCall, info: &DispatchInfoOf<Config::RuntimeCall>, len: usize, self_implicit: Self::Implicit, inherited_implication: &impl Implication, source: TransactionSource, ) -> Result<(ValidTransaction, Self::Val, Config::RuntimeOrigin), TransactionValidityError>

Validate a transaction for the transaction queue.

fn prepare( self, val: Self::Val, origin: &Config::RuntimeOrigin, call: &Config::RuntimeCall, info: &DispatchInfoOf<Config::RuntimeCall>, len: usize, ) -> Result<Self::Pre, TransactionValidityError>

Do any pre-flight stuff for a transaction after validation.

fn post_dispatch_details( pre: Self::Pre, info: &DispatchInfoOf<Config::RuntimeCall>, post_info: &PostDispatchInfo, len: usize, result: &DispatchResult, ) -> Result<Weight, TransactionValidityError>

Do any post-flight stuff for an extrinsic.

fn bare_validate( call: &Config::RuntimeCall, info: &DispatchInfoOf<Config::RuntimeCall>, len: usize, ) -> TransactionValidity

Validation logic for bare extrinsics.

fn bare_validate_and_prepare( call: &Config::RuntimeCall, info: &DispatchInfoOf<Config::RuntimeCall>, len: usize, ) -> Result<(), TransactionValidityError>

All pre-flight logic run before dispatching bare extrinsics.

fn bare_post_dispatch( info: &DispatchInfoOf<Config::RuntimeCall>, post_info: &mut PostDispatchInfoOf<Config::RuntimeCall>, len: usize, result: &DispatchResult, ) -> Result<(), TransactionValidityError>

Post dispatch logic run after dispatching bare extrinsics.

fn post_dispatch( pre: Self::Pre, info: &<Call as Dispatchable>::Info, post_info: &mut <Call as Dispatchable>::PostInfo, len: usize, result: &Result<(), DispatchError>, ) -> Result<(), TransactionValidityError>

A wrapper for post_dispatch_details that refunds the unspent weight consumed by this extension into the post dispatch information.

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> TypeInfo for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

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

type Identity = DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> DecodeWithMemTracking for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: DecodeWithMemTracking, PhantomData<(Config, TargetBlockRate)>: DecodeWithMemTracking,

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> EncodeLike for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: Encode, PhantomData<(Config, TargetBlockRate)>: Encode,

impl<Config, Inner, TargetBlockRate, const MAX_TRANSACTION_TO_CONSIDER: u32, const ALLOW_NORMAL: bool> Eq for DynamicMaxBlockWeight<Config, Inner, TargetBlockRate, MAX_TRANSACTION_TO_CONSIDER, ALLOW_NORMAL>

where Inner: Eq,