From 7493873c39498248ffa3f4c23430eeeb29934b22 Mon Sep 17 00:00:00 2001 From: Serban Iorga Date: Mon, 17 Feb 2025 14:31:38 +0200 Subject: [PATCH 1/5] Derive DecodeWithMemTracking for primitives --- substrate/frame/support/src/dispatch.rs | 35 +++++++++-- .../frame/support/src/traits/messages.rs | 4 +- .../frame/support/src/traits/preimages.rs | 14 ++++- .../frame/support/src/traits/schedule.rs | 15 ++++- .../src/traits/tokens/fungible/union_of.rs | 6 +- .../frame/support/src/traits/tokens/misc.rs | 13 +++- substrate/frame/system/src/lib.rs | 15 ++++- .../primitives/application-crypto/src/lib.rs | 4 ++ .../primitives/arithmetic/src/fixed_point.rs | 3 +- substrate/primitives/arithmetic/src/lib.rs | 15 ++++- .../primitives/arithmetic/src/per_things.rs | 4 +- substrate/primitives/core/src/crypto.rs | 15 ++++- substrate/primitives/core/src/crypto_bytes.rs | 4 +- substrate/primitives/core/src/lib.rs | 15 ++++- .../primitives/runtime/src/generic/digest.rs | 8 ++- .../primitives/runtime/src/generic/header.rs | 6 +- substrate/primitives/runtime/src/lib.rs | 61 ++++++++++++++++--- .../primitives/runtime/src/multiaddress.rs | 13 +++- .../runtime/src/proving_trie/mod.rs | 15 ++++- substrate/primitives/runtime/src/testing.rs | 17 +++++- .../primitives/runtime/src/traits/mod.rs | 1 + substrate/primitives/weights/src/weight_v2.rs | 16 ++++- substrate/test-utils/runtime/src/lib.rs | 4 +- 23 files changed, 253 insertions(+), 50 deletions(-) diff --git a/substrate/frame/support/src/dispatch.rs b/substrate/frame/support/src/dispatch.rs index 14bc2667def17..92284f370a5f3 100644 --- a/substrate/frame/support/src/dispatch.rs +++ b/substrate/frame/support/src/dispatch.rs @@ -19,7 +19,7 @@ //! generating values representing lazy module function calls. use crate::traits::UnfilteredDispatchable; -use codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen}; +use codec::{Codec, Decode, DecodeWithMemTracking, Encode, EncodeLike, MaxEncodedLen}; use core::fmt; use scale_info::TypeInfo; #[cfg(feature = "std")] @@ -72,7 +72,17 @@ pub trait CheckIfFeeless { } /// Origin for the System pallet. -#[derive(PartialEq, Eq, Clone, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Clone, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, +)] pub enum RawOrigin { /// The system itself ordained this dispatch to happen: this is the highest privilege level. Root, @@ -135,7 +145,9 @@ pub trait PaysFee { } /// Explicit enum to denote if a transaction pays fee or not. -#[derive(Clone, Copy, Eq, PartialEq, RuntimeDebug, Encode, Decode, TypeInfo)] +#[derive( + Clone, Copy, Eq, PartialEq, RuntimeDebug, Encode, Decode, DecodeWithMemTracking, TypeInfo, +)] pub enum Pays { /// Transactor will pay related fees. Yes, @@ -170,7 +182,9 @@ impl From for Pays { /// [DispatchClass::all] and [DispatchClass::non_mandatory] helper functions. #[cfg_attr(feature = "std", derive(Serialize, Deserialize))] #[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] -#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive( + PartialEq, Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo, +)] pub enum DispatchClass { /// A normal dispatch. Normal, @@ -291,7 +305,18 @@ pub fn extract_actual_pays_fee(result: &DispatchResultWithPostInfo, info: &Dispa /// Weight information that is only available post dispatch. /// NOTE: This can only be used to reduce the weight or fee, not increase it. -#[derive(Clone, Copy, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo)] +#[derive( + Clone, + Copy, + Eq, + PartialEq, + Default, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, +)] pub struct PostDispatchInfo { /// Actual weight consumed by a call or `None` which stands for the worst case static weight. pub actual_weight: Option, diff --git a/substrate/frame/support/src/traits/messages.rs b/substrate/frame/support/src/traits/messages.rs index d28716237119e..f2bbb2fdadabe 100644 --- a/substrate/frame/support/src/traits/messages.rs +++ b/substrate/frame/support/src/traits/messages.rs @@ -18,7 +18,7 @@ //! Traits for managing message queuing and handling. use super::storage::Footprint; -use codec::{Decode, Encode, FullCodec, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, FullCodec, MaxEncodedLen}; use core::{fmt::Debug, marker::PhantomData}; use scale_info::TypeInfo; use sp_core::{ConstU32, Get, TypedGet}; @@ -27,7 +27,7 @@ use sp_weights::{Weight, WeightMeter}; /// Errors that can happen when attempting to process a message with /// [`ProcessMessage::process_message()`]. -#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, TypeInfo, Debug)] +#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, DecodeWithMemTracking, TypeInfo, Debug)] pub enum ProcessMessageError { /// The message data format is unknown (e.g. unrecognised header) BadFormat, diff --git a/substrate/frame/support/src/traits/preimages.rs b/substrate/frame/support/src/traits/preimages.rs index 6e46a7489654e..e0c76b8bdff81 100644 --- a/substrate/frame/support/src/traits/preimages.rs +++ b/substrate/frame/support/src/traits/preimages.rs @@ -18,7 +18,7 @@ //! Stuff for dealing with hashed preimages. use alloc::borrow::Cow; -use codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, EncodeLike, MaxEncodedLen}; use scale_info::TypeInfo; use sp_core::RuntimeDebug; use sp_runtime::{ @@ -31,7 +31,17 @@ pub type BoundedInline = crate::BoundedVec>; /// The maximum we expect a single legacy hash lookup to be. const MAX_LEGACY_LEN: u32 = 1_000_000; -#[derive(Encode, Decode, MaxEncodedLen, Clone, Eq, PartialEq, TypeInfo, RuntimeDebug)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + Clone, + Eq, + PartialEq, + TypeInfo, + RuntimeDebug, +)] #[codec(mel_bound())] pub enum Bounded { /// A hash with no preimage length. We do not support creation of this except diff --git a/substrate/frame/support/src/traits/schedule.rs b/substrate/frame/support/src/traits/schedule.rs index a302e28d4ce24..2bf53d5f45a98 100644 --- a/substrate/frame/support/src/traits/schedule.rs +++ b/substrate/frame/support/src/traits/schedule.rs @@ -20,7 +20,7 @@ #[allow(deprecated)] use super::PreimageProvider; use alloc::vec::Vec; -use codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen}; +use codec::{Codec, Decode, DecodeWithMemTracking, Encode, EncodeLike, MaxEncodedLen}; use core::{fmt::Debug, result::Result}; use scale_info::TypeInfo; use sp_runtime::{traits::Saturating, DispatchError, RuntimeDebug}; @@ -35,7 +35,18 @@ pub type Period = (BlockNumber, u32); pub type Priority = u8; /// The dispatch time of a scheduled task. -#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum DispatchTime { /// At specified block. At(BlockNumber), diff --git a/substrate/frame/support/src/traits/tokens/fungible/union_of.rs b/substrate/frame/support/src/traits/tokens/fungible/union_of.rs index 5cb1d0a9e7b07..f8d476d517fe4 100644 --- a/substrate/frame/support/src/traits/tokens/fungible/union_of.rs +++ b/substrate/frame/support/src/traits/tokens/fungible/union_of.rs @@ -20,7 +20,7 @@ //! //! See the [`crate::traits::fungible`] doc for more information about fungible traits. -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::cmp::Ordering; use frame_support::traits::{ fungible::imbalance, @@ -40,7 +40,9 @@ use sp_runtime::{ /// The `NativeOrWithId` enum classifies an asset as either `Native` to the current chain or as an /// asset with a specific ID. -#[derive(Decode, Encode, Default, MaxEncodedLen, TypeInfo, Clone, RuntimeDebug, Eq)] +#[derive( + Decode, DecodeWithMemTracking, Encode, Default, MaxEncodedLen, TypeInfo, Clone, RuntimeDebug, Eq, +)] pub enum NativeOrWithId where AssetId: Ord, diff --git a/substrate/frame/support/src/traits/tokens/misc.rs b/substrate/frame/support/src/traits/tokens/misc.rs index 52d3e8c014b31..4978016603dcb 100644 --- a/substrate/frame/support/src/traits/tokens/misc.rs +++ b/substrate/frame/support/src/traits/tokens/misc.rs @@ -18,7 +18,7 @@ //! Miscellaneous types. use crate::{traits::Contains, TypeInfo}; -use codec::{Decode, Encode, FullCodec, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, FullCodec, MaxEncodedLen}; use core::fmt::Debug; use sp_arithmetic::traits::{AtLeast32BitUnsigned, Zero}; use sp_core::RuntimeDebug; @@ -178,7 +178,16 @@ pub enum ExistenceRequirement { /// Status of funds. #[derive( - PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug, scale_info::TypeInfo, MaxEncodedLen, + PartialEq, + Eq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + scale_info::TypeInfo, + MaxEncodedLen, )] pub enum BalanceStatus { /// Funds are free, as corresponding to `free` item in Balances. diff --git a/substrate/frame/system/src/lib.rs b/substrate/frame/system/src/lib.rs index 8980c6d6c8f42..9a21c65902983 100644 --- a/substrate/frame/system/src/lib.rs +++ b/substrate/frame/system/src/lib.rs @@ -122,7 +122,7 @@ use sp_runtime::{ }; use sp_version::RuntimeVersion; -use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, EncodeLike, FullCodec, MaxEncodedLen}; #[cfg(feature = "std")] use frame_support::traits::BuildGenesisConfig; use frame_support::{ @@ -267,7 +267,18 @@ where /// Information about the dispatch of a call, to be displayed in the /// [`ExtrinsicSuccess`](Event::ExtrinsicSuccess) and [`ExtrinsicFailed`](Event::ExtrinsicFailed) /// events. -#[derive(Clone, Copy, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo)] +#[derive( + Clone, + Copy, + Eq, + PartialEq, + Default, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, +)] pub struct DispatchEventInfo { /// Weight of this transaction. pub weight: Weight, diff --git a/substrate/primitives/application-crypto/src/lib.rs b/substrate/primitives/application-crypto/src/lib.rs index a8eb6b786a317..818062717cfce 100644 --- a/substrate/primitives/application-crypto/src/lib.rs +++ b/substrate/primitives/application-crypto/src/lib.rs @@ -251,6 +251,7 @@ macro_rules! app_crypto_public_full_crypto { Clone, Eq, Hash, PartialEq, PartialOrd, Ord, $crate::codec::Encode, $crate::codec::Decode, + $crate::codec::DecodeWithMemTracking, $crate::RuntimeDebug, $crate::codec::MaxEncodedLen, $crate::scale_info::TypeInfo, @@ -287,6 +288,7 @@ macro_rules! app_crypto_public_not_full_crypto { Clone, Eq, Hash, PartialEq, Ord, PartialOrd, $crate::codec::Encode, $crate::codec::Decode, + $crate::codec::DecodeWithMemTracking, $crate::RuntimeDebug, $crate::codec::MaxEncodedLen, $crate::scale_info::TypeInfo, @@ -432,6 +434,7 @@ macro_rules! app_crypto_signature_full_crypto { #[derive(Clone, Eq, PartialEq, $crate::codec::Encode, $crate::codec::Decode, + $crate::codec::DecodeWithMemTracking, $crate::RuntimeDebug, $crate::scale_info::TypeInfo, )] @@ -466,6 +469,7 @@ macro_rules! app_crypto_signature_not_full_crypto { #[derive(Clone, Eq, PartialEq, $crate::codec::Encode, $crate::codec::Decode, + $crate::codec::DecodeWithMemTracking, $crate::RuntimeDebug, $crate::scale_info::TypeInfo, )] diff --git a/substrate/primitives/arithmetic/src/fixed_point.rs b/substrate/primitives/arithmetic/src/fixed_point.rs index c4e9259c5fc94..9b5ef81917ca2 100644 --- a/substrate/primitives/arithmetic/src/fixed_point.rs +++ b/substrate/primitives/arithmetic/src/fixed_point.rs @@ -52,7 +52,7 @@ use crate::{ }, PerThing, Perbill, Rounding, SignedRounding, }; -use codec::{CompactAs, Decode, Encode}; +use codec::{CompactAs, Decode, DecodeWithMemTracking, Encode}; use core::{ fmt::Debug, ops::{self, Add, Div, Mul, Sub}, @@ -404,6 +404,7 @@ macro_rules! implement_fixed { #[derive( Encode, Decode, + DecodeWithMemTracking, CompactAs, Default, Copy, diff --git a/substrate/primitives/arithmetic/src/lib.rs b/substrate/primitives/arithmetic/src/lib.rs index 01c403a7c4af2..7ac51543ba333 100644 --- a/substrate/primitives/arithmetic/src/lib.rs +++ b/substrate/primitives/arithmetic/src/lib.rs @@ -55,14 +55,25 @@ use alloc::vec::Vec; use core::{cmp::Ordering, fmt::Debug}; use traits::{BaseArithmetic, One, SaturatedConversion, Unsigned, Zero}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; /// Arithmetic errors. -#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] +#[derive( + Eq, + PartialEq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Debug, + TypeInfo, + MaxEncodedLen, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum ArithmeticError { /// Underflow. diff --git a/substrate/primitives/arithmetic/src/per_things.rs b/substrate/primitives/arithmetic/src/per_things.rs index f73dbe30cec17..6d0394cd1da54 100644 --- a/substrate/primitives/arithmetic/src/per_things.rs +++ b/substrate/primitives/arithmetic/src/per_things.rs @@ -58,7 +58,7 @@ use crate::traits::{ BaseArithmetic, Bounded, CheckedAdd, CheckedMul, CheckedSub, One, SaturatedConversion, Saturating, UniqueSaturatedInto, Unsigned, Zero, }; -use codec::{CompactAs, Encode}; +use codec::{CompactAs, DecodeWithMemTracking, Encode}; use core::{ fmt, ops, ops::{Add, Sub}, @@ -592,7 +592,7 @@ macro_rules! implement_per_thing { /// #[doc = $title] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] - #[derive(Encode, Copy, Clone, PartialEq, Eq, codec::MaxEncodedLen, PartialOrd, Ord, scale_info::TypeInfo)] + #[derive(Encode, DecodeWithMemTracking, Copy, Clone, PartialEq, Eq, codec::MaxEncodedLen, PartialOrd, Ord, scale_info::TypeInfo)] pub struct $name($type); /// Implementation makes any compact encoding of `PerThing::Inner` valid, diff --git a/substrate/primitives/core/src/crypto.rs b/substrate/primitives/core/src/crypto.rs index cf24861e233c1..4838b48c0cd28 100644 --- a/substrate/primitives/core/src/crypto.rs +++ b/substrate/primitives/core/src/crypto.rs @@ -22,7 +22,7 @@ use alloc::{format, str, vec::Vec}; #[cfg(all(not(feature = "std"), feature = "serde"))] use alloc::{string::String, vec}; use bip39::{Language, Mnemonic}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::hash::Hash; #[doc(hidden)] pub use core::ops::Deref; @@ -501,7 +501,18 @@ pub trait Public: CryptoType + ByteArray + PartialEq + Eq + Clone + Send + Sync pub trait Signature: CryptoType + ByteArray + PartialEq + Eq + Clone + Send + Sync {} /// An opaque 32-byte cryptographic identifier. -#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, TypeInfo)] +#[derive( + Clone, + Eq, + PartialEq, + Ord, + PartialOrd, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, +)] #[cfg_attr(feature = "std", derive(Hash))] pub struct AccountId32([u8; 32]); diff --git a/substrate/primitives/core/src/crypto_bytes.rs b/substrate/primitives/core/src/crypto_bytes.rs index e5130e6d50079..1964109cfac82 100644 --- a/substrate/primitives/core/src/crypto_bytes.rs +++ b/substrate/primitives/core/src/crypto_bytes.rs @@ -22,7 +22,7 @@ use crate::{ hash::{H256, H512}, }; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::marker::PhantomData; use scale_info::TypeInfo; @@ -47,7 +47,7 @@ pub use signature_bytes::*; /// The tag `T` is held in a `PhantomDataT>`, a trick allowing /// `CryptoBytes` to be `Send` and `Sync` regardless of `T` properties /// ([ref](https://doc.rust-lang.org/nomicon/phantom-data.html#table-of-phantomdata-patterns)). -#[derive(Encode, Decode, MaxEncodedLen)] +#[derive(Encode, Decode, DecodeWithMemTracking, MaxEncodedLen)] #[repr(transparent)] pub struct CryptoBytes(pub [u8; N], PhantomData T>); diff --git a/substrate/primitives/core/src/lib.rs b/substrate/primitives/core/src/lib.rs index 454f61df79419..db2dfcb7a6e29 100644 --- a/substrate/primitives/core/src/lib.rs +++ b/substrate/primitives/core/src/lib.rs @@ -35,7 +35,7 @@ extern crate alloc; use alloc::vec::Vec; #[doc(hidden)] -pub use codec::{Decode, Encode, MaxEncodedLen}; +pub use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::ops::Deref; use scale_info::TypeInfo; #[cfg(feature = "serde")] @@ -178,6 +178,7 @@ impl Deref for OpaqueMetadata { PartialOrd, Encode, Decode, + DecodeWithMemTracking, RuntimeDebug, PassByInner, TypeInfo, @@ -324,7 +325,17 @@ pub fn to_substrate_wasm_fn_return_value(value: &impl Encode) -> u64 { /// The void type - it cannot exist. // Oh rust, you crack me up... -#[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Decode, + DecodeWithMemTracking, + Encode, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum Void {} /// Macro for creating `Maybe*` marker traits. diff --git a/substrate/primitives/runtime/src/generic/digest.rs b/substrate/primitives/runtime/src/generic/digest.rs index 5ed0c7075cae6..593fbdd66c477 100644 --- a/substrate/primitives/runtime/src/generic/digest.rs +++ b/substrate/primitives/runtime/src/generic/digest.rs @@ -25,7 +25,7 @@ use codec::DecodeAll; use serde::{Deserialize, Serialize}; use crate::{ - codec::{Decode, Encode, Error, Input}, + codec::{Decode, DecodeWithMemTracking, Encode, Error, Input}, scale_info::{ build::{Fields, Variants}, Path, Type, TypeInfo, @@ -35,7 +35,9 @@ use crate::{ use sp_core::RuntimeDebug; /// Generic header digest. -#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, Default)] +#[derive( + PartialEq, Eq, Clone, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo, Default, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct Digest { /// A list of logs in the digest. @@ -71,7 +73,7 @@ impl Digest { /// Digest item that is able to encode/decode 'system' digest items and /// provide opaque access to other items. -#[derive(PartialEq, Eq, Clone, RuntimeDebug)] +#[derive(PartialEq, Eq, Clone, DecodeWithMemTracking, RuntimeDebug)] pub enum DigestItem { /// A pre-runtime digest. /// diff --git a/substrate/primitives/runtime/src/generic/header.rs b/substrate/primitives/runtime/src/generic/header.rs index d78aa5c8d3c29..cde8098404b44 100644 --- a/substrate/primitives/runtime/src/generic/header.rs +++ b/substrate/primitives/runtime/src/generic/header.rs @@ -18,7 +18,7 @@ //! Generic implementation of a block header. use crate::{ - codec::{Codec, Decode, Encode}, + codec::{Codec, Decode, DecodeWithMemTracking, Encode}, generic::Digest, scale_info::TypeInfo, traits::{self, AtLeast32BitUnsigned, BlockNumber, Hash as HashT, MaybeDisplay, Member}, @@ -28,7 +28,9 @@ use serde::{Deserialize, Serialize}; use sp_core::U256; /// Abstraction over a block header for a substrate chain. -#[derive(Encode, Decode, PartialEq, Eq, Clone, sp_core::RuntimeDebug, TypeInfo)] +#[derive( + Encode, Decode, DecodeWithMemTracking, PartialEq, Eq, Clone, sp_core::RuntimeDebug, TypeInfo, +)] #[scale_info(skip_type_params(Hash))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))] diff --git a/substrate/primitives/runtime/src/lib.rs b/substrate/primitives/runtime/src/lib.rs index f0c8e50f1ba1e..cd5dd725c35a7 100644 --- a/substrate/primitives/runtime/src/lib.rs +++ b/substrate/primitives/runtime/src/lib.rs @@ -80,7 +80,7 @@ use sp_core::{ }; use alloc::vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; pub mod curve; @@ -272,7 +272,17 @@ pub type ConsensusEngineId = [u8; 4]; /// Signature verify that can work with any known signature types. #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] -#[derive(Eq, PartialEq, Clone, Encode, Decode, MaxEncodedLen, RuntimeDebug, TypeInfo)] +#[derive( + Eq, + PartialEq, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + RuntimeDebug, + TypeInfo, +)] pub enum MultiSignature { /// An Ed25519 signature. Ed25519(ed25519::Signature), @@ -511,7 +521,9 @@ pub type DispatchResult = core::result::Result<(), DispatchError>; pub type DispatchResultWithInfo = core::result::Result>; /// Reason why a pallet call failed. -#[derive(Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] +#[derive( + Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, Debug, TypeInfo, MaxEncodedLen, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct ModuleError { /// Module index, matching the metadata module index. @@ -531,7 +543,18 @@ impl PartialEq for ModuleError { } /// Errors related to transactional storage layers. -#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] +#[derive( + Eq, + PartialEq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Debug, + TypeInfo, + MaxEncodedLen, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum TransactionalError { /// Too many transactional layers have been spawned. @@ -556,7 +579,18 @@ impl From for DispatchError { } /// Reason why a dispatch call failed. -#[derive(Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo, PartialEq, MaxEncodedLen)] +#[derive( + Eq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Debug, + TypeInfo, + PartialEq, + MaxEncodedLen, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum DispatchError { /// Some error occurred. @@ -598,7 +632,9 @@ pub enum DispatchError { /// Result of a `Dispatchable` which contains the `DispatchResult` and additional information about /// the `Dispatchable` that is only known post dispatch. -#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive( + Eq, PartialEq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo, +)] pub struct DispatchErrorWithPostInfo where Info: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable, @@ -643,7 +679,18 @@ impl From for DispatchError { } /// Description of what went wrong when trying to complete an operation on a token. -#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] +#[derive( + Eq, + PartialEq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Debug, + TypeInfo, + MaxEncodedLen, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum TokenError { /// Funds are unavailable. diff --git a/substrate/primitives/runtime/src/multiaddress.rs b/substrate/primitives/runtime/src/multiaddress.rs index 4382405a8ebc6..5a309af704206 100644 --- a/substrate/primitives/runtime/src/multiaddress.rs +++ b/substrate/primitives/runtime/src/multiaddress.rs @@ -18,10 +18,19 @@ //! MultiAddress type is a wrapper for multiple downstream account formats. use alloc::vec::Vec; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; /// A multi-format address wrapper for on-chain accounts. -#[derive(Encode, Decode, PartialEq, Eq, Clone, crate::RuntimeDebug, scale_info::TypeInfo)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + PartialEq, + Eq, + Clone, + crate::RuntimeDebug, + scale_info::TypeInfo, +)] #[cfg_attr(feature = "std", derive(Hash))] pub enum MultiAddress { /// It's an account ID (pubkey). diff --git a/substrate/primitives/runtime/src/proving_trie/mod.rs b/substrate/primitives/runtime/src/proving_trie/mod.rs index 32b2284b4d79d..bd5ddbe974292 100644 --- a/substrate/primitives/runtime/src/proving_trie/mod.rs +++ b/substrate/primitives/runtime/src/proving_trie/mod.rs @@ -20,14 +20,25 @@ pub mod base16; pub mod base2; -use crate::{Decode, DispatchError, Encode, MaxEncodedLen, TypeInfo}; +use crate::{Decode, DecodeWithMemTracking, DispatchError, Encode, MaxEncodedLen, TypeInfo}; #[cfg(feature = "serde")] use crate::{Deserialize, Serialize}; use alloc::vec::Vec; use sp_trie::{trie_types::TrieError as SpTrieError, VerifyError}; /// A runtime friendly error type for tries. -#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] +#[derive( + Eq, + PartialEq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Debug, + TypeInfo, + MaxEncodedLen, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum TrieError { /* From TrieError */ diff --git a/substrate/primitives/runtime/src/testing.rs b/substrate/primitives/runtime/src/testing.rs index 1fc78cce6707c..3f037eb153b9f 100644 --- a/substrate/primitives/runtime/src/testing.rs +++ b/substrate/primitives/runtime/src/testing.rs @@ -18,7 +18,7 @@ //! Testing utilities. use crate::{ - codec::{Codec, Decode, Encode, MaxEncodedLen}, + codec::{Codec, Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}, generic::{self, UncheckedExtrinsic}, scale_info::TypeInfo, traits::{self, BlakeTwo256, Dispatchable, OpaqueKeys}, @@ -42,6 +42,7 @@ use std::{cell::RefCell, fmt::Debug}; Clone, Encode, Decode, + DecodeWithMemTracking, Debug, Hash, Serialize, @@ -165,7 +166,19 @@ impl traits::Verify for UintAuthorityId { } /// A dummy signature type, to match `UintAuthorityId`. -#[derive(Eq, PartialEq, Clone, Debug, Hash, Serialize, Deserialize, Encode, Decode, TypeInfo)] +#[derive( + Eq, + PartialEq, + Clone, + Debug, + Hash, + Serialize, + Deserialize, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, +)] pub struct TestSignature(pub u64, pub Vec); impl traits::Verify for TestSignature { diff --git a/substrate/primitives/runtime/src/traits/mod.rs b/substrate/primitives/runtime/src/traits/mod.rs index 46f17a0fcc633..3781120fa4488 100644 --- a/substrate/primitives/runtime/src/traits/mod.rs +++ b/substrate/primitives/runtime/src/traits/mod.rs @@ -2066,6 +2066,7 @@ macro_rules! impl_opaque_keys_inner { Clone, PartialEq, Eq, $crate::codec::Encode, $crate::codec::Decode, + $crate::codec::DecodeWithMemTracking, $crate::scale_info::TypeInfo, $crate::RuntimeDebug, )] diff --git a/substrate/primitives/weights/src/weight_v2.rs b/substrate/primitives/weights/src/weight_v2.rs index 0f92e6448ca94..87e6e69c49f63 100644 --- a/substrate/primitives/weights/src/weight_v2.rs +++ b/substrate/primitives/weights/src/weight_v2.rs @@ -15,13 +15,25 @@ // See the License for the specific language governing permissions and // limitations under the License. -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign}; use sp_arithmetic::traits::{Bounded, CheckedAdd, CheckedSub, Zero}; use super::*; -#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, Eq, PartialEq, Copy, Clone, Debug, Default)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + Eq, + PartialEq, + Copy, + Clone, + Debug, + Default, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))] pub struct Weight { diff --git a/substrate/test-utils/runtime/src/lib.rs b/substrate/test-utils/runtime/src/lib.rs index 7c092f2851663..b5d3bf2dbbea7 100644 --- a/substrate/test-utils/runtime/src/lib.rs +++ b/substrate/test-utils/runtime/src/lib.rs @@ -29,7 +29,7 @@ pub mod substrate_test_pallet; #[cfg(not(feature = "std"))] use alloc::{vec, vec::Vec}; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use frame_support::{ construct_runtime, derive_impl, dispatch::DispatchClass, @@ -135,7 +135,7 @@ pub fn native_version() -> NativeVersion { } /// Transfer data extracted from Extrinsic containing `Balances::transfer_allow_death`. -#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive(Clone, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo)] pub struct TransferData { pub from: AccountId, pub to: AccountId, From f50c773f77603478833e645bb89fa453145f947b Mon Sep 17 00:00:00 2001 From: Serban Iorga Date: Mon, 17 Feb 2025 16:48:48 +0200 Subject: [PATCH 2/5] Derive DecodeWithMemTracking for frame pallets --- substrate/frame/alliance/src/lib.rs | 12 +- substrate/frame/alliance/src/mock.rs | 2 +- substrate/frame/alliance/src/types.rs | 39 +++++- substrate/frame/atomic-swap/src/lib.rs | 26 +++- substrate/frame/bags-list/src/list/mod.rs | 14 +- substrate/frame/balances/src/types.rs | 14 +- substrate/frame/beefy/src/mock.rs | 4 +- substrate/frame/broker/src/core_mask.rs | 14 +- .../frame/broker/src/coretime_interface.rs | 14 +- substrate/frame/broker/src/types.rs | 64 ++++++++- substrate/frame/collective/src/lib.rs | 14 +- substrate/frame/contracts/src/lib.rs | 6 +- substrate/frame/contracts/src/wasm/mod.rs | 13 +- .../frame/conviction-voting/src/conviction.rs | 3 +- substrate/frame/conviction-voting/src/vote.rs | 19 ++- substrate/frame/core-fellowship/src/lib.rs | 16 ++- substrate/frame/democracy/src/conviction.rs | 3 +- substrate/frame/democracy/src/types.rs | 14 +- substrate/frame/democracy/src/vote.rs | 17 ++- .../frame/democracy/src/vote_threshold.rs | 13 +- .../election-provider-multi-block/src/lib.rs | 10 +- .../src/types.rs | 16 ++- .../src/verifier/mod.rs | 11 +- .../election-provider-multi-phase/src/lib.rs | 23 +++- .../solution-type/src/single_page.rs | 3 +- .../election-provider-support/src/lib.rs | 8 +- substrate/frame/elections-phragmen/src/lib.rs | 4 +- substrate/frame/identity/src/legacy.rs | 3 +- substrate/frame/identity/src/types.rs | 17 ++- substrate/frame/im-online/src/lib.rs | 4 +- substrate/frame/message-queue/src/lib.rs | 2 +- .../frame/message-queue/src/mock_helpers.rs | 13 +- substrate/frame/migrations/src/lib.rs | 30 +++- substrate/frame/multisig/src/lib.rs | 12 +- substrate/frame/nfts/src/types.rs | 129 ++++++++++++++++-- substrate/frame/nomination-pools/src/lib.rs | 61 +++++++-- substrate/frame/proxy/src/tests.rs | 1 + substrate/frame/ranked-collective/src/lib.rs | 16 ++- substrate/frame/referenda/src/mock.rs | 6 +- substrate/frame/safe-mode/src/lib.rs | 13 +- substrate/frame/safe-mode/src/mock.rs | 1 + substrate/frame/society/src/lib.rs | 13 +- substrate/frame/staking/src/lib.rs | 41 +++++- substrate/frame/staking/src/pallet/mod.rs | 2 +- .../frame/state-trie-migration/src/lib.rs | 25 +++- substrate/frame/support/src/lib.rs | 2 +- substrate/frame/tx-pause/src/mock.rs | 1 + substrate/frame/uniques/src/lib.rs | 2 +- substrate/frame/uniques/src/types.rs | 13 +- substrate/frame/vesting/src/lib.rs | 2 +- substrate/frame/vesting/src/vesting_info.rs | 13 +- .../primitives/consensus/babe/src/digests.rs | 12 +- .../primitives/consensus/babe/src/lib.rs | 15 +- .../consensus/beefy/src/commitment.rs | 4 +- .../primitives/consensus/beefy/src/lib.rs | 10 +- .../primitives/consensus/beefy/src/payload.rs | 16 ++- .../primitives/consensus/grandpa/src/lib.rs | 6 +- .../primitives/consensus/sassafras/src/lib.rs | 14 +- .../consensus/sassafras/src/ticket.rs | 10 +- .../primitives/consensus/slots/src/lib.rs | 19 ++- substrate/primitives/core/src/bandersnatch.rs | 6 +- .../merkle-mountain-range/src/lib.rs | 3 +- .../primitives/npos-elections/src/lib.rs | 27 +++- substrate/primitives/session/src/lib.rs | 14 +- .../primitives/statement-store/src/lib.rs | 17 ++- .../transaction-storage-proof/src/lib.rs | 4 +- 66 files changed, 844 insertions(+), 151 deletions(-) diff --git a/substrate/frame/alliance/src/lib.rs b/substrate/frame/alliance/src/lib.rs index be65f49e6e4ea..234fd59ef89fd 100644 --- a/substrate/frame/alliance/src/lib.rs +++ b/substrate/frame/alliance/src/lib.rs @@ -204,7 +204,17 @@ pub enum MemberRole { } /// The type of item that may be deemed unscrupulous. -#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + PartialEq, + Eq, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, +)] pub enum UnscrupulousItem { AccountId(AccountId), Website(Url), diff --git a/substrate/frame/alliance/src/mock.rs b/substrate/frame/alliance/src/mock.rs index 069c29a88d38c..b2b4ba4d5bf91 100644 --- a/substrate/frame/alliance/src/mock.rs +++ b/substrate/frame/alliance/src/mock.rs @@ -126,7 +126,7 @@ impl pallet_identity::Config for Test { type WeightInfo = (); } -#[derive(Clone, Debug, Encode, Decode, PartialEq, Eq, TypeInfo)] +#[derive(Clone, Debug, Encode, Decode, DecodeWithMemTracking, PartialEq, Eq, TypeInfo)] pub struct AccountU64(u64); impl IdentifyAccount for AccountU64 { type AccountId = u64; diff --git a/substrate/frame/alliance/src/types.rs b/substrate/frame/alliance/src/types.rs index 75b949c19b325..2c7112652d664 100644 --- a/substrate/frame/alliance/src/types.rs +++ b/substrate/frame/alliance/src/types.rs @@ -16,14 +16,24 @@ // limitations under the License. use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use frame_support::{traits::ConstU32, BoundedVec}; use scale_info::TypeInfo; use sp_runtime::RuntimeDebug; /// A Multihash instance that only supports the basic functionality and no hashing. #[derive( - Clone, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen, + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, )] pub struct Multihash { /// The code of the Multihash. @@ -50,6 +60,7 @@ impl Multihash { RuntimeDebug, Encode, Decode, + DecodeWithMemTracking, TypeInfo, MaxEncodedLen, )] @@ -64,7 +75,17 @@ pub enum Version { /// /// The generic is about the allocated size of the multihash. #[derive( - Clone, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen, + Clone, + PartialEq, + Eq, + PartialOrd, + Ord, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, )] pub struct Cid { /// The version of CID. @@ -96,7 +117,17 @@ impl Cid { /// Witness data for the `disband` call. #[derive( - Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo, Default, + Copy, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + MaxEncodedLen, + TypeInfo, + Default, )] pub struct DisbandWitness { /// Total number of fellow members in the current Alliance. diff --git a/substrate/frame/atomic-swap/src/lib.rs b/substrate/frame/atomic-swap/src/lib.rs index 9521f20fe0092..f35f0efa618ab 100644 --- a/substrate/frame/atomic-swap/src/lib.rs +++ b/substrate/frame/atomic-swap/src/lib.rs @@ -45,7 +45,7 @@ mod tests; extern crate alloc; use alloc::vec::Vec; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use core::{ marker::PhantomData, ops::{Deref, DerefMut}, @@ -57,7 +57,17 @@ use frame::{ use scale_info::TypeInfo; /// Pending atomic swap operation. -#[derive(Clone, Eq, PartialEq, RuntimeDebugNoBound, Encode, Decode, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Eq, + PartialEq, + RuntimeDebugNoBound, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, +)] #[scale_info(skip_type_params(T))] #[codec(mel_bound())] pub struct PendingSwap { @@ -92,7 +102,17 @@ pub trait SwapAction { } /// A swap action that only allows transferring balances. -#[derive(Clone, RuntimeDebug, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + RuntimeDebug, + Eq, + PartialEq, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, +)] #[scale_info(skip_type_params(C))] #[codec(mel_bound())] pub struct BalanceSwapAction> { diff --git a/substrate/frame/bags-list/src/list/mod.rs b/substrate/frame/bags-list/src/list/mod.rs index 6bcc8efbd5d4a..1fe4ffffaa658 100644 --- a/substrate/frame/bags-list/src/list/mod.rs +++ b/substrate/frame/bags-list/src/list/mod.rs @@ -29,7 +29,7 @@ use alloc::{ boxed::Box, collections::{btree_map::BTreeMap, btree_set::BTreeSet}, }; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{iter, marker::PhantomData}; use frame_election_provider_support::ScoreProvider; use frame_support::{ @@ -51,7 +51,17 @@ use alloc::vec::Vec; #[cfg(any(test, feature = "try-runtime", feature = "fuzz"))] use sp_runtime::TryRuntimeError; -#[derive(Debug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo, PalletError)] +#[derive( + Debug, + PartialEq, + Eq, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + PalletError, +)] pub enum ListError { /// A duplicate id has been detected. Duplicate, diff --git a/substrate/frame/balances/src/types.rs b/substrate/frame/balances/src/types.rs index 917b7507d7c94..7f39274789118 100644 --- a/substrate/frame/balances/src/types.rs +++ b/substrate/frame/balances/src/types.rs @@ -18,7 +18,7 @@ //! Types used in the pallet. use crate::{Config, CreditOf, Event, Pallet}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::ops::BitOr; use frame_support::traits::{Imbalance, LockIdentifier, OnUnbalanced, WithdrawReasons}; use scale_info::TypeInfo; @@ -145,7 +145,17 @@ impl, I: 'static> Drop for DustCleaner { } /// Whether something should be interpreted as an increase or a decrease. -#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + MaxEncodedLen, + TypeInfo, +)] pub enum AdjustmentDirection { /// Increase the amount. Increase, diff --git a/substrate/frame/beefy/src/mock.rs b/substrate/frame/beefy/src/mock.rs index 655a36ab14612..275bf18fe873d 100644 --- a/substrate/frame/beefy/src/mock.rs +++ b/substrate/frame/beefy/src/mock.rs @@ -15,7 +15,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use frame_election_provider_support::{ bounds::{ElectionBounds, ElectionBoundsBuilder}, onchain, SequentialPhragmen, Weight, @@ -95,7 +95,7 @@ pub struct MockAncestryProofContext { pub is_valid: bool, } -#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, TypeInfo)] pub struct MockAncestryProof { pub is_optimal: bool, pub is_non_canonical: bool, diff --git a/substrate/frame/broker/src/core_mask.rs b/substrate/frame/broker/src/core_mask.rs index b8d045077d828..507bc0897bd21 100644 --- a/substrate/frame/broker/src/core_mask.rs +++ b/substrate/frame/broker/src/core_mask.rs @@ -15,7 +15,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not}; use scale_info::TypeInfo; use sp_core::RuntimeDebug; @@ -25,7 +25,17 @@ pub const CORE_MASK_BITS: usize = 80; // TODO: Use BitArr instead; for this, we'll need to ensure Codec is impl'ed for `BitArr`. #[derive( - Encode, Decode, Default, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, + Encode, + Decode, + DecodeWithMemTracking, + Default, + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, )] pub struct CoreMask([u8; 10]); impl CoreMask { diff --git a/substrate/frame/broker/src/coretime_interface.rs b/substrate/frame/broker/src/coretime_interface.rs index 9c18e2c4ff0b3..618c3d70fc561 100644 --- a/substrate/frame/broker/src/coretime_interface.rs +++ b/substrate/frame/broker/src/coretime_interface.rs @@ -18,7 +18,7 @@ #![deny(missing_docs)] use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::fmt::Debug; use frame_support::Parameter; use scale_info::TypeInfo; @@ -39,7 +39,17 @@ pub type PartsOf57600 = u16; /// An element to which a core can be assigned. #[derive( - Encode, Decode, Clone, Eq, PartialEq, Ord, PartialOrd, RuntimeDebug, TypeInfo, MaxEncodedLen, + Encode, + Decode, + DecodeWithMemTracking, + Clone, + Eq, + PartialEq, + Ord, + PartialOrd, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, )] pub enum CoreAssignment { /// Core need not be used for anything. diff --git a/substrate/frame/broker/src/types.rs b/substrate/frame/broker/src/types.rs index f970b310a3cba..ec04b9d9b1f62 100644 --- a/substrate/frame/broker/src/types.rs +++ b/substrate/frame/broker/src/types.rs @@ -19,7 +19,7 @@ use crate::{ Config, CoreAssignment, CoreIndex, CoreMask, CoretimeInterface, RCBlockNumberOf, TaskId, CORE_MASK_BITS, }; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use frame_support::traits::fungible::Inspect; use frame_system::Config as SConfig; use scale_info::TypeInfo; @@ -42,7 +42,18 @@ pub type CoreMaskBitCount = u32; pub type SignedCoreMaskBitCount = i32; /// Whether a core assignment is revokable or not. -#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum Finality { /// The region remains with the same owner allowing the assignment to be altered. Provisional, @@ -51,7 +62,18 @@ pub enum Finality { } /// Self-describing identity for a Region of Bulk Coretime. -#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct RegionId { /// The timeslice at which this Region begins. pub begin: Timeslice, @@ -91,7 +113,17 @@ pub struct RegionRecord { pub type RegionRecordOf = RegionRecord<::AccountId, BalanceOf>; /// An distinct item which can be scheduled on a Polkadot Core. -#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct ScheduleItem { /// The regularity parts in which this Item will be scheduled on the Core. pub mask: CoreMask, @@ -259,7 +291,17 @@ pub type LeasesRecordOf = LeasesRecord<::MaxLeasedCores>; /// /// The blocknumber is the relay chain block height `until` which the original request /// for revenue was made. -#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct OnDemandRevenueRecord { /// The height of the Relay-chain at the time the revenue request was made. pub until: RelayBlockNumber, @@ -271,7 +313,17 @@ pub type OnDemandRevenueRecordOf = OnDemandRevenueRecord, RelayBalanceOf>; /// Configuration of this pallet. -#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct ConfigRecord { /// The number of Relay-chain blocks in advance which scheduling should be fixed and the /// `Coretime::assign` API used to inform the Relay-chain. diff --git a/substrate/frame/collective/src/lib.rs b/substrate/frame/collective/src/lib.rs index 8e533a7b29043..a7bd00a7f4114 100644 --- a/substrate/frame/collective/src/lib.rs +++ b/substrate/frame/collective/src/lib.rs @@ -44,7 +44,7 @@ extern crate alloc; use alloc::{boxed::Box, vec, vec::Vec}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{marker::PhantomData, result}; use scale_info::TypeInfo; use sp_io::storage; @@ -137,7 +137,17 @@ impl DefaultVote for MoreThanMajorityThenPrimeDefaultVote { } /// Origin for the collective module. -#[derive(PartialEq, Eq, Clone, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Clone, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, +)] #[scale_info(skip_type_params(I))] #[codec(mel_bound(AccountId: MaxEncodedLen))] pub enum RawOrigin { diff --git a/substrate/frame/contracts/src/lib.rs b/substrate/frame/contracts/src/lib.rs index 7bb5b46cf527f..627aca17c9c94 100644 --- a/substrate/frame/contracts/src/lib.rs +++ b/substrate/frame/contracts/src/lib.rs @@ -116,7 +116,7 @@ use crate::{ storage::{meter::Meter as StorageMeter, ContractInfo, DeletionQueueManager}, wasm::{CodeInfo, RuntimeCosts, WasmBlob}, }; -use codec::{Codec, Decode, Encode, HasCompact, MaxEncodedLen}; +use codec::{Codec, Decode, DecodeWithMemTracking, Encode, HasCompact, MaxEncodedLen}; use core::fmt::Debug; use environmental::*; use frame_support::{ @@ -1382,7 +1382,9 @@ pub mod pallet { } /// The type of origins supported by the contracts pallet. -#[derive(Clone, Encode, Decode, PartialEq, TypeInfo, RuntimeDebugNoBound)] +#[derive( + Clone, Encode, Decode, DecodeWithMemTracking, PartialEq, TypeInfo, RuntimeDebugNoBound, +)] pub enum Origin { Root, Signed(T::AccountId), diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs index c9786fa1516b5..399ed1ccded75 100644 --- a/substrate/frame/contracts/src/wasm/mod.rs +++ b/substrate/frame/contracts/src/wasm/mod.rs @@ -49,7 +49,7 @@ use crate::{ HoldReason, Pallet, PristineCode, Schedule, Weight, LOG_TARGET, }; use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use frame_support::{ dispatch::DispatchResult, ensure, @@ -106,7 +106,16 @@ pub struct CodeInfo { /// Defines the required determinism level of a wasm blob when either running or uploading code. #[derive( - Clone, Copy, Encode, Decode, scale_info::TypeInfo, MaxEncodedLen, RuntimeDebug, PartialEq, Eq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + scale_info::TypeInfo, + MaxEncodedLen, + RuntimeDebug, + PartialEq, + Eq, )] pub enum Determinism { /// The execution should be deterministic and hence no indeterministic instructions are diff --git a/substrate/frame/conviction-voting/src/conviction.rs b/substrate/frame/conviction-voting/src/conviction.rs index b5c9a3a705f6b..4332c8e4a0a7c 100644 --- a/substrate/frame/conviction-voting/src/conviction.rs +++ b/substrate/frame/conviction-voting/src/conviction.rs @@ -17,7 +17,7 @@ //! The conviction datatype. -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use sp_runtime::{ traits::{Bounded, CheckedDiv, CheckedMul, Zero}, @@ -30,6 +30,7 @@ use crate::types::Delegations; #[derive( Encode, Decode, + DecodeWithMemTracking, Copy, Clone, Eq, diff --git a/substrate/frame/conviction-voting/src/vote.rs b/substrate/frame/conviction-voting/src/vote.rs index 1c5b742ba12b1..84c7dafd52c4a 100644 --- a/substrate/frame/conviction-voting/src/vote.rs +++ b/substrate/frame/conviction-voting/src/vote.rs @@ -18,7 +18,7 @@ //! The vote datatype. use crate::{Conviction, Delegations}; -use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen, Output}; +use codec::{Decode, DecodeWithMemTracking, Encode, EncodeLike, Input, MaxEncodedLen, Output}; use frame_support::{pallet_prelude::Get, BoundedVec}; use scale_info::TypeInfo; use sp_runtime::{ @@ -27,7 +27,9 @@ use sp_runtime::{ }; /// A number of lock periods, plus a vote, one way or the other. -#[derive(Copy, Clone, Eq, PartialEq, Default, RuntimeDebug, MaxEncodedLen)] +#[derive( + DecodeWithMemTracking, Copy, Clone, Eq, PartialEq, Default, RuntimeDebug, MaxEncodedLen, +)] pub struct Vote { pub aye: bool, pub conviction: Conviction, @@ -66,7 +68,18 @@ impl TypeInfo for Vote { } /// A vote for a referendum of a particular account. -#[derive(Encode, Decode, Copy, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Copy, + Clone, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum AccountVote { /// A standard vote, one-way (approve or reject) with a given amount of conviction. Standard { vote: Vote, balance: Balance }, diff --git a/substrate/frame/core-fellowship/src/lib.rs b/substrate/frame/core-fellowship/src/lib.rs index 77ea937eac7a9..3d2da6e9f717e 100644 --- a/substrate/frame/core-fellowship/src/lib.rs +++ b/substrate/frame/core-fellowship/src/lib.rs @@ -62,7 +62,7 @@ extern crate alloc; use alloc::boxed::Box; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{fmt::Debug, marker::PhantomData}; use scale_info::TypeInfo; use sp_arithmetic::traits::{Saturating, Zero}; @@ -91,7 +91,18 @@ pub use pallet::*; pub use weights::*; /// The desired outcome for which evidence is presented. -#[derive(Encode, Decode, Eq, PartialEq, Copy, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + Copy, + Clone, + TypeInfo, + MaxEncodedLen, + RuntimeDebug, +)] pub enum Wish { /// Member wishes only to retain their current rank. Retention, @@ -109,6 +120,7 @@ pub type Evidence = BoundedVec>::EvidenceSize>; #[derive( Encode, Decode, + DecodeWithMemTracking, CloneNoBound, EqNoBound, PartialEqNoBound, diff --git a/substrate/frame/democracy/src/conviction.rs b/substrate/frame/democracy/src/conviction.rs index 54f4ff524f2a9..64c062ce9434c 100644 --- a/substrate/frame/democracy/src/conviction.rs +++ b/substrate/frame/democracy/src/conviction.rs @@ -18,7 +18,7 @@ //! The conviction datatype. use crate::types::Delegations; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::result::Result; use scale_info::TypeInfo; use sp_runtime::{ @@ -31,6 +31,7 @@ use sp_runtime::{ Encode, MaxEncodedLen, Decode, + DecodeWithMemTracking, Copy, Clone, Eq, diff --git a/substrate/frame/democracy/src/types.rs b/substrate/frame/democracy/src/types.rs index ee6e2e0aa2537..88a7435a3b162 100644 --- a/substrate/frame/democracy/src/types.rs +++ b/substrate/frame/democracy/src/types.rs @@ -18,7 +18,7 @@ //! Miscellaneous additional datatypes. use crate::{AccountVote, Conviction, Vote, VoteThreshold}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use sp_runtime::{ traits::{Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Saturating, Zero}, @@ -214,7 +214,17 @@ pub enum UnvoteScope { } /// Identifies an owner of a metadata. -#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum MetadataOwner { /// External proposal. External, diff --git a/substrate/frame/democracy/src/vote.rs b/substrate/frame/democracy/src/vote.rs index 779f7ecd570f0..c1103d4da32e5 100644 --- a/substrate/frame/democracy/src/vote.rs +++ b/substrate/frame/democracy/src/vote.rs @@ -18,7 +18,7 @@ //! The vote datatype. use crate::{Conviction, Delegations, ReferendumIndex}; -use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen, Output}; +use codec::{Decode, DecodeWithMemTracking, Encode, EncodeLike, Input, MaxEncodedLen, Output}; use frame_support::traits::Get; use scale_info::TypeInfo; use sp_runtime::{ @@ -27,7 +27,7 @@ use sp_runtime::{ }; /// A number of lock periods, plus a vote, one way or the other. -#[derive(Copy, Clone, Eq, PartialEq, Default, RuntimeDebug)] +#[derive(DecodeWithMemTracking, Copy, Clone, Eq, PartialEq, Default, RuntimeDebug)] pub struct Vote { pub aye: bool, pub conviction: Conviction, @@ -72,7 +72,18 @@ impl TypeInfo for Vote { } /// A vote for a referendum of a particular account. -#[derive(Encode, MaxEncodedLen, Decode, Copy, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[derive( + Encode, + DecodeWithMemTracking, + MaxEncodedLen, + Decode, + Copy, + Clone, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, +)] pub enum AccountVote { /// A standard vote, one-way (approve or reject) with a given amount of conviction. Standard { vote: Vote, balance: Balance }, diff --git a/substrate/frame/democracy/src/vote_threshold.rs b/substrate/frame/democracy/src/vote_threshold.rs index 82d6ed178f137..9e4e66897a06a 100644 --- a/substrate/frame/democracy/src/vote_threshold.rs +++ b/substrate/frame/democracy/src/vote_threshold.rs @@ -18,7 +18,7 @@ //! Voting thresholds. use crate::Tally; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::ops::{Add, Div, Mul, Rem}; use scale_info::TypeInfo; #[cfg(feature = "std")] @@ -27,7 +27,16 @@ use sp_runtime::traits::{IntegerSquareRoot, Zero}; /// A means of determining if a vote is past pass threshold. #[derive( - Clone, Copy, PartialEq, Eq, Encode, MaxEncodedLen, Decode, sp_runtime::RuntimeDebug, TypeInfo, + Clone, + Copy, + PartialEq, + Eq, + Encode, + DecodeWithMemTracking, + MaxEncodedLen, + Decode, + sp_runtime::RuntimeDebug, + TypeInfo, )] #[cfg_attr(feature = "std", derive(Serialize, Deserialize))] pub enum VoteThreshold { diff --git a/substrate/frame/election-provider-multi-block/src/lib.rs b/substrate/frame/election-provider-multi-block/src/lib.rs index ea30fb239aee3..86a94c67c5844 100644 --- a/substrate/frame/election-provider-multi-block/src/lib.rs +++ b/substrate/frame/election-provider-multi-block/src/lib.rs @@ -324,7 +324,15 @@ impl From for ElectionError { /// Different operations that the [`Config::AdminOrigin`] can perform on the pallet. #[derive( - Encode, Decode, MaxEncodedLen, TypeInfo, DebugNoBound, CloneNoBound, PartialEqNoBound, EqNoBound, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + DebugNoBound, + CloneNoBound, + PartialEqNoBound, + EqNoBound, )] #[codec(mel_bound(T: Config))] #[scale_info(skip_type_params(T))] diff --git a/substrate/frame/election-provider-multi-block/src/types.rs b/substrate/frame/election-provider-multi-block/src/types.rs index 9657277a79e42..f74c9aee05311 100644 --- a/substrate/frame/election-provider-multi-block/src/types.rs +++ b/substrate/frame/election-provider-multi-block/src/types.rs @@ -22,7 +22,7 @@ use sp_core::Get; use sp_std::{collections::btree_set::BTreeSet, fmt::Debug, prelude::*}; use crate::unsigned::miner::MinerConfig; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use frame_election_provider_support::ElectionProvider; pub use frame_election_provider_support::{NposSolution, PageIndex}; use scale_info::TypeInfo; @@ -53,6 +53,7 @@ pub type AssignmentOf = TypeInfo, Encode, Decode, + DecodeWithMemTracking, DebugNoBound, CloneNoBound, EqNoBound, @@ -230,7 +231,18 @@ impl Default for ElectionCompute { } /// Current phase of the pallet. -#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, MaxEncodedLen, Debug, TypeInfo)] +#[derive( + PartialEq, + Eq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + Debug, + TypeInfo, +)] pub enum Phase { /// Nothing is happening, and nothing will happen. Halted, diff --git a/substrate/frame/election-provider-multi-block/src/verifier/mod.rs b/substrate/frame/election-provider-multi-block/src/verifier/mod.rs index 98391daa546c4..a5f7c4aa5c3da 100644 --- a/substrate/frame/election-provider-multi-block/src/verifier/mod.rs +++ b/substrate/frame/election-provider-multi-block/src/verifier/mod.rs @@ -78,7 +78,16 @@ use sp_std::{fmt::Debug, prelude::*}; pub use crate::weights::measured::pallet_election_provider_multi_block_verifier::*; /// Errors that can happen in the feasibility check. -#[derive(Debug, Eq, PartialEq, codec::Encode, codec::Decode, scale_info::TypeInfo, Clone)] +#[derive( + Debug, + Eq, + PartialEq, + codec::Encode, + codec::Decode, + codec::DecodeWithMemTracking, + scale_info::TypeInfo, + Clone, +)] pub enum FeasibilityError { /// Wrong number of winners presented. WrongWinnerCount, diff --git a/substrate/frame/election-provider-multi-phase/src/lib.rs b/substrate/frame/election-provider-multi-phase/src/lib.rs index 3a5103d2bb8ab..c0e256c3e6525 100644 --- a/substrate/frame/election-provider-multi-phase/src/lib.rs +++ b/substrate/frame/election-provider-multi-phase/src/lib.rs @@ -244,7 +244,7 @@ extern crate alloc; use alloc::{boxed::Box, vec::Vec}; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use frame_election_provider_support::{ bounds::{CountBound, ElectionBounds, SizeBound}, BoundedSupports, BoundedSupportsOf, ElectionDataProvider, ElectionProvider, @@ -336,7 +336,7 @@ pub trait BenchmarkingConfig { } /// Current phase of the pallet. -#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo)] +#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, Debug, TypeInfo)] pub enum Phase { /// Nothing, the election is not happening. Off, @@ -398,7 +398,7 @@ impl Phase { } /// The type of `Computation` that provided this election data. -#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo)] +#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, Debug, TypeInfo)] pub enum ElectionCompute { /// Election was computed on-chain. OnChain, @@ -424,7 +424,18 @@ impl Default for ElectionCompute { /// /// Such a solution should never become effective in anyway before being checked by the /// `Pallet::feasibility_check`. -#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, PartialOrd, Ord, TypeInfo)] +#[derive( + PartialEq, + Eq, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + PartialOrd, + Ord, + TypeInfo, +)] pub struct RawSolution { /// the solution itself. pub solution: S, @@ -490,7 +501,9 @@ pub struct RoundSnapshot { /// This is stored automatically on-chain, and it contains the **size of the entire snapshot**. /// This is also used in dispatchables as weight witness data and should **only contain the size of /// the presented solution**, not the entire snapshot. -#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, Debug, Default, TypeInfo)] +#[derive( + PartialEq, Eq, Clone, Copy, Encode, Decode, DecodeWithMemTracking, Debug, Default, TypeInfo, +)] pub struct SolutionOrSnapshotSize { /// The length of voters. #[codec(compact)] diff --git a/substrate/frame/election-provider-support/solution-type/src/single_page.rs b/substrate/frame/election-provider-support/solution-type/src/single_page.rs index f57dcb9694a83..c921be34b3430 100644 --- a/substrate/frame/election-provider-support/solution-type/src/single_page.rs +++ b/substrate/frame/election-provider-support/solution-type/src/single_page.rs @@ -74,7 +74,7 @@ pub(crate) fn generate(def: crate::SolutionDef) -> Result { ); quote! { #compact_impl - #[derive(Default, PartialEq, Eq, Clone, Debug, PartialOrd, Ord)] + #[derive(Default, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, _fepsp::codec::DecodeWithMemTracking)] } } else { // automatically derived. @@ -88,6 +88,7 @@ pub(crate) fn generate(def: crate::SolutionDef) -> Result { PartialOrd, _fepsp::codec::Encode, _fepsp::codec::Decode, + _fepsp::codec::DecodeWithMemTracking, _fepsp::scale_info::TypeInfo, )]) }; diff --git a/substrate/frame/election-provider-support/src/lib.rs b/substrate/frame/election-provider-support/src/lib.rs index 68aee2c82e62b..27f8d96e5e791 100644 --- a/substrate/frame/election-provider-support/src/lib.rs +++ b/substrate/frame/election-provider-support/src/lib.rs @@ -209,7 +209,7 @@ use sp_runtime::{ }; pub use bounds::DataProviderBounds; -pub use codec::{Decode, Encode, MaxEncodedLen}; +pub use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; /// Re-export the solution generation macro. pub use frame_election_provider_solution_type::generate_solution_type; pub use frame_support::{traits::Get, weights::Weight, BoundedVec, DefaultNoBound}; @@ -830,7 +830,9 @@ pub type VoterOf = Voter<::AccountId, ::MaxVotesPerVoter>; /// A bounded vector of supports. Bounded equivalent to [`sp_npos_elections::Supports`]. -#[derive(Default, Debug, Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)] +#[derive( + Default, Debug, Encode, Decode, DecodeWithMemTracking, scale_info::TypeInfo, MaxEncodedLen, +)] #[codec(mel_bound(AccountId: MaxEncodedLen, Bound: Get))] #[scale_info(skip_type_params(Bound))] pub struct BoundedSupport> { @@ -906,7 +908,7 @@ impl> BoundedSupport { /// corresponds to the bound of the maximum winners that the bounded supports may contain. /// /// With the bounds, we control the maximum size of a bounded supports instance. -#[derive(Encode, Decode, TypeInfo, DefaultNoBound, MaxEncodedLen)] +#[derive(Encode, Decode, DecodeWithMemTracking, TypeInfo, DefaultNoBound, MaxEncodedLen)] #[codec(mel_bound(AccountId: MaxEncodedLen, BOuter: Get, BInner: Get))] #[scale_info(skip_type_params(BOuter, BInner))] pub struct BoundedSupports, BInner: Get>( diff --git a/substrate/frame/elections-phragmen/src/lib.rs b/substrate/frame/elections-phragmen/src/lib.rs index 4a40d44e40776..d73cd510f820d 100644 --- a/substrate/frame/elections-phragmen/src/lib.rs +++ b/substrate/frame/elections-phragmen/src/lib.rs @@ -101,7 +101,7 @@ extern crate alloc; use alloc::{vec, vec::Vec}; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use core::cmp::Ordering; use frame_support::{ traits::{ @@ -139,7 +139,7 @@ type NegativeImbalanceOf = <::Currency as Currency< >>::NegativeImbalance; /// An indication that the renouncing account currently has which of the below roles. -#[derive(Encode, Decode, Clone, PartialEq, RuntimeDebug, TypeInfo)] +#[derive(Encode, Decode, DecodeWithMemTracking, Clone, PartialEq, RuntimeDebug, TypeInfo)] pub enum Renouncing { /// A member is renouncing. Member, diff --git a/substrate/frame/identity/src/legacy.rs b/substrate/frame/identity/src/legacy.rs index de5b9f79b559b..a5ef069f9268c 100644 --- a/substrate/frame/identity/src/legacy.rs +++ b/substrate/frame/identity/src/legacy.rs @@ -17,7 +17,7 @@ #[cfg(feature = "runtime-benchmarks")] use alloc::vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; #[cfg(feature = "runtime-benchmarks")] use enumflags2::BitFlag; use enumflags2::{bitflags, BitFlags}; @@ -69,6 +69,7 @@ impl TypeInfo for IdentityField { CloneNoBound, Encode, Decode, + DecodeWithMemTracking, EqNoBound, MaxEncodedLen, PartialEqNoBound, diff --git a/substrate/frame/identity/src/types.rs b/substrate/frame/identity/src/types.rs index ece3c34f82efc..85f2f8f8597bc 100644 --- a/substrate/frame/identity/src/types.rs +++ b/substrate/frame/identity/src/types.rs @@ -17,7 +17,7 @@ use super::*; use alloc::{vec, vec::Vec}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{fmt::Debug, iter::once, ops::Add}; use frame_support::{ traits::{ConstU32, Get}, @@ -39,7 +39,7 @@ pub type RegistrarIndex = u32; /// than 32-bytes then it will be truncated when encoding. /// /// Can also be `None`. -#[derive(Clone, Eq, PartialEq, RuntimeDebug, MaxEncodedLen)] +#[derive(Clone, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, MaxEncodedLen)] pub enum Data { /// No data here. None, @@ -190,7 +190,18 @@ impl Default for Data { /// /// NOTE: Registrars may pay little attention to some fields. Registrars may want to make clear /// which fields their attestation is relevant for by off-chain means. -#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)] +#[derive( + Copy, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + MaxEncodedLen, + TypeInfo, +)] pub enum Judgement { /// The default value; no opinion is held. diff --git a/substrate/frame/im-online/src/lib.rs b/substrate/frame/im-online/src/lib.rs index 74d3bc6484dd4..28d97489d9814 100644 --- a/substrate/frame/im-online/src/lib.rs +++ b/substrate/frame/im-online/src/lib.rs @@ -85,7 +85,7 @@ pub mod weights; extern crate alloc; use alloc::{vec, vec::Vec}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use frame_support::{ pallet_prelude::*, traits::{ @@ -218,7 +218,7 @@ impl core::fmt::Debug for OffchainErr where BlockNumber: PartialEq + Eq + Decode + Encode, diff --git a/substrate/frame/message-queue/src/lib.rs b/substrate/frame/message-queue/src/lib.rs index 9cd3e42d70dd2..0e2a2f6b01b4a 100644 --- a/substrate/frame/message-queue/src/lib.rs +++ b/substrate/frame/message-queue/src/lib.rs @@ -206,7 +206,7 @@ pub mod weights; extern crate alloc; use alloc::{vec, vec::Vec}; -use codec::{Codec, Decode, Encode, MaxEncodedLen}; +use codec::{Codec, Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{fmt::Debug, ops::Deref}; use frame_support::{ defensive, diff --git a/substrate/frame/message-queue/src/mock_helpers.rs b/substrate/frame/message-queue/src/mock_helpers.rs index 873add776e209..9730d0c6fd22e 100644 --- a/substrate/frame/message-queue/src/mock_helpers.rs +++ b/substrate/frame/message-queue/src/mock_helpers.rs @@ -37,7 +37,18 @@ impl IntoWeight for u64 { } /// Mocked message origin for testing. -#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, MaxEncodedLen, TypeInfo, Debug)] +#[derive( + Copy, + Clone, + Eq, + PartialEq, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + Debug, +)] pub enum MessageOrigin { Here, There, diff --git a/substrate/frame/migrations/src/lib.rs b/substrate/frame/migrations/src/lib.rs index fef61468e6e4e..5fcbc2ee62980 100644 --- a/substrate/frame/migrations/src/lib.rs +++ b/substrate/frame/migrations/src/lib.rs @@ -157,7 +157,7 @@ pub use pallet::*; pub use weights::WeightInfo; use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::ops::ControlFlow; use frame_support::{ defensive, defensive_assert, @@ -174,7 +174,17 @@ use frame_system::{ use sp_runtime::Saturating; /// Points to the next migration to execute. -#[derive(Debug, Clone, Eq, PartialEq, Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)] +#[derive( + Debug, + Clone, + Eq, + PartialEq, + Encode, + Decode, + DecodeWithMemTracking, + scale_info::TypeInfo, + MaxEncodedLen, +)] pub enum MigrationCursor { /// Points to the currently active migration and its inner cursor. Active(ActiveCursor), @@ -202,7 +212,17 @@ impl From> } /// Points to the currently active migration and its inner cursor. -#[derive(Debug, Clone, Eq, PartialEq, Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)] +#[derive( + Debug, + Clone, + Eq, + PartialEq, + Encode, + Decode, + DecodeWithMemTracking, + scale_info::TypeInfo, + MaxEncodedLen, +)] pub struct ActiveCursor { /// The index of the migration in the MBM tuple. pub index: u32, @@ -224,7 +244,9 @@ impl ActiveCursor { } /// How to clear the records of historic migrations. -#[derive(Debug, Clone, Eq, PartialEq, Encode, Decode, scale_info::TypeInfo)] +#[derive( + Debug, Clone, Eq, PartialEq, Encode, Decode, DecodeWithMemTracking, scale_info::TypeInfo, +)] pub enum HistoricCleanupSelector { /// Clear exactly these entries. /// diff --git a/substrate/frame/multisig/src/lib.rs b/substrate/frame/multisig/src/lib.rs index 2da5ab9c337f0..6fdc52d6887d0 100644 --- a/substrate/frame/multisig/src/lib.rs +++ b/substrate/frame/multisig/src/lib.rs @@ -84,7 +84,17 @@ pub type BlockNumberFor = /// block's height. This allows a transaction in which a multisig operation of a particular /// composite was created to be uniquely identified. #[derive( - Copy, Clone, Eq, PartialEq, Encode, Decode, Default, RuntimeDebug, TypeInfo, MaxEncodedLen, + Copy, + Clone, + Eq, + PartialEq, + Encode, + Decode, + DecodeWithMemTracking, + Default, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, )] pub struct Timepoint { /// The height of the chain at the point in time. diff --git a/substrate/frame/nfts/src/types.rs b/substrate/frame/nfts/src/types.rs index 3ab85993473a2..d606ecb0e6400 100644 --- a/substrate/frame/nfts/src/types.rs +++ b/substrate/frame/nfts/src/types.rs @@ -108,7 +108,18 @@ pub struct CollectionDetails { } /// Witness data for the destroy transactions. -#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Copy, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct DestroyWitness { /// The total number of items in this collection that have outstanding item metadata. #[codec(compact)] @@ -132,7 +143,9 @@ impl CollectionDetails { } /// Witness data for items mint transactions. -#[derive(Clone, Encode, Decode, Default, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[derive( + Clone, Encode, Decode, DecodeWithMemTracking, Default, Eq, PartialEq, RuntimeDebug, TypeInfo, +)] pub struct MintWitness { /// Provide the id of the item in a required collection. pub owned_item: Option, @@ -191,7 +204,17 @@ pub struct ItemMetadata> { } /// Information about the tip. -#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct ItemTip { /// The collection of the item. pub collection: CollectionId, @@ -235,7 +258,17 @@ pub struct ItemMetadataDeposit { } /// Specifies whether the tokens will be sent or received. -#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum PriceDirection { /// Tokens will be sent. Send, @@ -244,7 +277,17 @@ pub enum PriceDirection { } /// Holds the details about the price. -#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct PriceWithDirection { /// An amount. pub amount: Amount, @@ -293,7 +336,18 @@ impl_codec_bitflags!(CollectionSettings, u64, CollectionSetting); /// Mint type. Can the NFT be create by anyone, or only the creator of the collection, /// or only by wallets that already hold an NFT from a certain collection? /// The ownership of a privately minted NFT is still publicly visible. -#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum MintType { /// Only an `Issuer` could mint items. Issuer, @@ -304,7 +358,18 @@ pub enum MintType { } /// Holds the information about minting. -#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct MintSettings { /// Whether anyone can mint or if minters are restricted to some subset. pub mint_type: MintType, @@ -332,7 +397,15 @@ impl Default for MintSettings { /// An attribute was set by the pallet. @@ -346,14 +419,24 @@ pub enum AttributeNamespace { } /// A witness data to cancel attributes approval operation. -#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[derive(Clone, Encode, Decode, DecodeWithMemTracking, Eq, PartialEq, RuntimeDebug, TypeInfo)] pub struct CancelAttributesApprovalWitness { /// An amount of attributes previously created by account. pub account_attributes: u32, } /// A list of possible pallet-level attributes. -#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum PalletAttributes { /// Marks an item as being used in order to claim another item. UsedToClaim(CollectionId), @@ -363,7 +446,16 @@ pub enum PalletAttributes { /// Collection's configuration. #[derive( - Clone, Copy, Decode, Default, Encode, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo, + Clone, + Copy, + Decode, + DecodeWithMemTracking, + Default, + Encode, + MaxEncodedLen, + PartialEq, + RuntimeDebug, + TypeInfo, )] pub struct CollectionConfig { /// Collection's settings. @@ -425,7 +517,16 @@ impl_codec_bitflags!(ItemSettings, u64, ItemSetting); /// Item's configuration. #[derive( - Encode, Decode, Default, PartialEq, RuntimeDebug, Clone, Copy, MaxEncodedLen, TypeInfo, + Encode, + Decode, + DecodeWithMemTracking, + Default, + PartialEq, + RuntimeDebug, + Clone, + Copy, + MaxEncodedLen, + TypeInfo, )] pub struct ItemConfig { /// Item's settings. @@ -516,7 +617,7 @@ impl CollectionRoles { } impl_codec_bitflags!(CollectionRoles, u8, CollectionRole); -#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive(Clone, Eq, PartialEq, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo)] pub struct PreSignedMint { /// A collection of the item to be minted. pub collection: CollectionId, @@ -534,7 +635,7 @@ pub struct PreSignedMint { pub mint_price: Option, } -#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive(Clone, Eq, PartialEq, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo)] pub struct PreSignedAttributes { /// Collection's ID. pub collection: CollectionId, diff --git a/substrate/frame/nomination-pools/src/lib.rs b/substrate/frame/nomination-pools/src/lib.rs index 86545cdee8583..39a7cf05b3aba 100644 --- a/substrate/frame/nomination-pools/src/lib.rs +++ b/substrate/frame/nomination-pools/src/lib.rs @@ -355,7 +355,7 @@ extern crate alloc; use adapter::{Member, Pool, StakeStrategy}; use alloc::{collections::btree_map::BTreeMap, vec::Vec}; -use codec::Codec; +use codec::{Codec, DecodeWithMemTracking}; use core::{fmt::Debug, ops::Div}; use frame_support::{ defensive, defensive_assert, ensure, @@ -422,7 +422,16 @@ pub type BlockNumberFor = pub const POINTS_TO_BALANCE_INIT_RATIO: u32 = 1; /// Possible operations on the configuration values of this pallet. -#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebugNoBound, PartialEq, Clone)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + RuntimeDebugNoBound, + PartialEq, + Clone, +)] pub enum ConfigOp { /// Don't change. Noop, @@ -441,7 +450,7 @@ pub enum BondType { } /// How to increase the bond of a member. -#[derive(Encode, Decode, Clone, Copy, Debug, PartialEq, Eq, TypeInfo)] +#[derive(Encode, Decode, DecodeWithMemTracking, Clone, Copy, Debug, PartialEq, Eq, TypeInfo)] pub enum BondExtra { /// Take from the free balance. FreeBalance(Balance), @@ -457,7 +466,18 @@ enum AccountType { } /// The permission a pool member can set for other accounts to claim rewards on their behalf. -#[derive(Encode, Decode, MaxEncodedLen, Clone, Copy, Debug, PartialEq, Eq, TypeInfo)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + Clone, + Copy, + Debug, + PartialEq, + Eq, + TypeInfo, +)] pub enum ClaimPermission { /// Only the pool member themselves can claim their rewards. Permissioned, @@ -671,7 +691,17 @@ impl PoolMember { } /// A pool's possible states. -#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, RuntimeDebugNoBound, Clone, Copy)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + PartialEq, + RuntimeDebugNoBound, + Clone, + Copy, +)] pub enum PoolState { /// The pool is open to be joined, and is working normally. Open, @@ -704,7 +734,18 @@ pub struct PoolRoles { } // A pool's possible commission claiming permissions. -#[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Copy, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum CommissionClaimPermission { Permissionless, Account(AccountId), @@ -918,7 +959,9 @@ impl Commission { /// blocks that must elapse before commission updates are allowed again. /// /// Commission change rates are not applied to decreases in commission. -#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, Debug, PartialEq, Copy, Clone)] +#[derive( + Encode, Decode, DecodeWithMemTracking, MaxEncodedLen, TypeInfo, Debug, PartialEq, Copy, Clone, +)] pub struct CommissionChangeRate { /// The maximum amount the commission can be updated by per `min_delay` period. pub max_increase: Perbill, @@ -2008,7 +2051,9 @@ pub mod pallet { NotSupported, } - #[derive(Encode, Decode, PartialEq, TypeInfo, PalletError, RuntimeDebug)] + #[derive( + Encode, Decode, DecodeWithMemTracking, PartialEq, TypeInfo, PalletError, RuntimeDebug, + )] pub enum DefensiveError { /// There isn't enough space in the unbond pool. NotEnoughSpaceInUnbondPool, diff --git a/substrate/frame/proxy/src/tests.rs b/substrate/frame/proxy/src/tests.rs index 14389b03ac7e2..b52dc5ce0e398 100644 --- a/substrate/frame/proxy/src/tests.rs +++ b/substrate/frame/proxy/src/tests.rs @@ -64,6 +64,7 @@ impl pallet_utility::Config for Test { PartialOrd, Encode, Decode, + DecodeWithMemTracking, RuntimeDebug, MaxEncodedLen, scale_info::TypeInfo, diff --git a/substrate/frame/ranked-collective/src/lib.rs b/substrate/frame/ranked-collective/src/lib.rs index e34cf3d8df711..4b1b3d9010db1 100644 --- a/substrate/frame/ranked-collective/src/lib.rs +++ b/substrate/frame/ranked-collective/src/lib.rs @@ -42,7 +42,7 @@ extern crate alloc; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::marker::PhantomData; use scale_info::TypeInfo; use sp_arithmetic::traits::Saturating; @@ -90,6 +90,7 @@ pub type Votes = u32; TypeInfo, Encode, Decode, + DecodeWithMemTracking, MaxEncodedLen, )] #[scale_info(skip_type_params(T, I, M))] @@ -189,7 +190,18 @@ impl MemberRecord { } /// Record needed for every vote. -#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum VoteRecord { /// Vote was an aye with given vote weight. Aye(Votes), diff --git a/substrate/frame/referenda/src/mock.rs b/substrate/frame/referenda/src/mock.rs index 5c9c12dee445c..52a89d3f7cb7d 100644 --- a/substrate/frame/referenda/src/mock.rs +++ b/substrate/frame/referenda/src/mock.rs @@ -20,7 +20,7 @@ use super::*; use crate::{self as pallet_referenda, types::Track}; use alloc::borrow::Cow; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use frame_support::{ assert_ok, derive_impl, ord_parameter_types, parameter_types, traits::{ @@ -239,7 +239,9 @@ impl ExtBuilder { } } -#[derive(Encode, Debug, Decode, TypeInfo, Eq, PartialEq, Clone, MaxEncodedLen)] +#[derive( + Encode, Debug, Decode, DecodeWithMemTracking, TypeInfo, Eq, PartialEq, Clone, MaxEncodedLen, +)] pub struct Tally { pub ayes: u32, pub nays: u32, diff --git a/substrate/frame/safe-mode/src/lib.rs b/substrate/frame/safe-mode/src/lib.rs index cfa9097b54121..110f46b032204 100644 --- a/substrate/frame/safe-mode/src/lib.rs +++ b/substrate/frame/safe-mode/src/lib.rs @@ -238,7 +238,18 @@ pub mod pallet { } /// The reason why the safe-mode was deactivated. - #[derive(Copy, Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)] + #[derive( + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + Encode, + Decode, + DecodeWithMemTracking, + TypeInfo, + MaxEncodedLen, + )] pub enum ExitReason { /// The safe-mode was automatically deactivated after it's duration ran out. Timeout, diff --git a/substrate/frame/safe-mode/src/mock.rs b/substrate/frame/safe-mode/src/mock.rs index 2980f86abc281..277fe20ec4122 100644 --- a/substrate/frame/safe-mode/src/mock.rs +++ b/substrate/frame/safe-mode/src/mock.rs @@ -91,6 +91,7 @@ impl pallet_utility::Config for Test { PartialOrd, Encode, Decode, + DecodeWithMemTracking, RuntimeDebug, MaxEncodedLen, scale_info::TypeInfo, diff --git a/substrate/frame/society/src/lib.rs b/substrate/frame/society/src/lib.rs index 03726e6215ca1..577c1a71f89d7 100644 --- a/substrate/frame/society/src/lib.rs +++ b/substrate/frame/society/src/lib.rs @@ -463,7 +463,18 @@ pub struct IntakeRecord { pub type IntakeRecordFor = IntakeRecord<::AccountId, BalanceOf>; -#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct GroupParams { max_members: u32, max_intake: u32, diff --git a/substrate/frame/staking/src/lib.rs b/substrate/frame/staking/src/lib.rs index 9105a3e7ec13a..a5fe16e500b8f 100644 --- a/substrate/frame/staking/src/lib.rs +++ b/substrate/frame/staking/src/lib.rs @@ -344,7 +344,7 @@ mod pallet; extern crate alloc; use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec}; -use codec::{Decode, Encode, HasCompact, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, HasCompact, MaxEncodedLen}; use frame_election_provider_support::ElectionProvider; use frame_support::{ defensive, defensive_assert, @@ -448,7 +448,18 @@ impl Default for EraRewardPoints { } /// A destination account for payment. -#[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Copy, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub enum RewardDestination { /// Pay into the stash account, increasing the amount at stake accordingly. Staked, @@ -465,7 +476,18 @@ pub enum RewardDestination { } /// Preference of what happens regarding validation. -#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, Default, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + TypeInfo, + Default, + MaxEncodedLen, +)] pub struct ValidatorPrefs { /// Reward that validator takes up-front; only the rest is split between themselves and /// nominators. @@ -478,7 +500,17 @@ pub struct ValidatorPrefs { } /// Just a Balance/BlockNumber tuple to encode when a chunk of funds will be unlocked. -#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + PartialEq, + Eq, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct UnlockChunk { /// Amount of funds to be unlocked. #[codec(compact)] @@ -997,6 +1029,7 @@ where Eq, Encode, Decode, + DecodeWithMemTracking, RuntimeDebug, TypeInfo, MaxEncodedLen, diff --git a/substrate/frame/staking/src/pallet/mod.rs b/substrate/frame/staking/src/pallet/mod.rs index 4184ac3bdde81..6bd52e2bce166 100644 --- a/substrate/frame/staking/src/pallet/mod.rs +++ b/substrate/frame/staking/src/pallet/mod.rs @@ -83,7 +83,7 @@ pub mod pallet { pub struct Pallet(_); /// Possible operations on the configuration values of this pallet. - #[derive(TypeInfo, Debug, Clone, Encode, Decode, PartialEq)] + #[derive(TypeInfo, Debug, Clone, Encode, Decode, DecodeWithMemTracking, PartialEq)] pub enum ConfigOp { /// Don't change. Noop, diff --git a/substrate/frame/state-trie-migration/src/lib.rs b/substrate/frame/state-trie-migration/src/lib.rs index 6e475b7067e16..1418ea0b6f0a4 100644 --- a/substrate/frame/state-trie-migration/src/lib.rs +++ b/substrate/frame/state-trie-migration/src/lib.rs @@ -106,6 +106,7 @@ pub mod pallet { CloneNoBound, Encode, Decode, + DecodeWithMemTracking, scale_info::TypeInfo, PartialEqNoBound, EqNoBound, @@ -127,7 +128,16 @@ pub mod pallet { /// A migration task stored in state. /// /// It tracks the last top and child keys read. - #[derive(Clone, Encode, Decode, scale_info::TypeInfo, PartialEq, Eq, MaxEncodedLen)] + #[derive( + Clone, + Encode, + Decode, + DecodeWithMemTracking, + scale_info::TypeInfo, + PartialEq, + Eq, + MaxEncodedLen, + )] #[scale_info(skip_type_params(T))] pub struct MigrationTask { /// The current top trie migration progress. @@ -404,6 +414,7 @@ pub mod pallet { Copy, Encode, Decode, + DecodeWithMemTracking, scale_info::TypeInfo, Default, Debug, @@ -419,7 +430,17 @@ pub mod pallet { } /// How a migration was computed. - #[derive(Clone, Copy, Encode, Decode, scale_info::TypeInfo, Debug, PartialEq, Eq)] + #[derive( + Clone, + Copy, + Encode, + Decode, + DecodeWithMemTracking, + scale_info::TypeInfo, + Debug, + PartialEq, + Eq, + )] pub enum MigrationCompute { /// A signed origin triggered the migration. Signed, diff --git a/substrate/frame/support/src/lib.rs b/substrate/frame/support/src/lib.rs index 825628fb01edb..86c7330d275de 100644 --- a/substrate/frame/support/src/lib.rs +++ b/substrate/frame/support/src/lib.rs @@ -914,7 +914,7 @@ pub mod pallet_prelude { Blake2_128, Blake2_128Concat, Blake2_256, CloneNoBound, DebugNoBound, EqNoBound, Identity, PartialEqNoBound, RuntimeDebugNoBound, Twox128, Twox256, Twox64Concat, }; - pub use codec::{Decode, Encode, MaxEncodedLen}; + pub use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; pub use core::marker::PhantomData; pub use frame_support::pallet_macros::*; pub use frame_support_procedural::{inject_runtime_type, register_default_impl}; diff --git a/substrate/frame/tx-pause/src/mock.rs b/substrate/frame/tx-pause/src/mock.rs index d543f447ca7a5..a34095a2ffdd2 100644 --- a/substrate/frame/tx-pause/src/mock.rs +++ b/substrate/frame/tx-pause/src/mock.rs @@ -58,6 +58,7 @@ impl pallet_utility::Config for Test { PartialOrd, Encode, Decode, + DecodeWithMemTracking, RuntimeDebug, MaxEncodedLen, scale_info::TypeInfo, diff --git a/substrate/frame/uniques/src/lib.rs b/substrate/frame/uniques/src/lib.rs index 01548418a0499..d2fa0adb11704 100644 --- a/substrate/frame/uniques/src/lib.rs +++ b/substrate/frame/uniques/src/lib.rs @@ -45,7 +45,7 @@ pub mod weights; extern crate alloc; use alloc::vec::Vec; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use frame_support::traits::{ tokens::Locker, BalanceStatus::Reserved, Currency, EnsureOriginWithArg, ReservableCurrency, }; diff --git a/substrate/frame/uniques/src/types.rs b/substrate/frame/uniques/src/types.rs index 6451e3800da8d..b17703223ca6f 100644 --- a/substrate/frame/uniques/src/types.rs +++ b/substrate/frame/uniques/src/types.rs @@ -62,7 +62,18 @@ pub struct CollectionDetails { } /// Witness data for the destroy transactions. -#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[derive( + Copy, + Clone, + Encode, + Decode, + DecodeWithMemTracking, + Eq, + PartialEq, + RuntimeDebug, + TypeInfo, + MaxEncodedLen, +)] pub struct DestroyWitness { /// The total number of outstanding items of this collection. #[codec(compact)] diff --git a/substrate/frame/vesting/src/lib.rs b/substrate/frame/vesting/src/lib.rs index 9e3e30106f341..357f454519dd9 100644 --- a/substrate/frame/vesting/src/lib.rs +++ b/substrate/frame/vesting/src/lib.rs @@ -59,7 +59,7 @@ pub mod weights; extern crate alloc; use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{fmt::Debug, marker::PhantomData}; use frame_support::{ dispatch::DispatchResult, diff --git a/substrate/frame/vesting/src/vesting_info.rs b/substrate/frame/vesting/src/vesting_info.rs index 5d5ae31fc3247..fd26ff3e6b77e 100644 --- a/substrate/frame/vesting/src/vesting_info.rs +++ b/substrate/frame/vesting/src/vesting_info.rs @@ -20,7 +20,18 @@ use super::*; /// Struct to encode the vesting schedule of an individual account. -#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Copy, + Clone, + PartialEq, + Eq, + RuntimeDebug, + MaxEncodedLen, + TypeInfo, +)] pub struct VestingInfo { /// Locked amount at genesis. locked: Balance, diff --git a/substrate/primitives/consensus/babe/src/digests.rs b/substrate/primitives/consensus/babe/src/digests.rs index e7af8c5763a0f..6516a3c0fd8eb 100644 --- a/substrate/primitives/consensus/babe/src/digests.rs +++ b/substrate/primitives/consensus/babe/src/digests.rs @@ -27,7 +27,7 @@ use alloc::vec::Vec; use sp_core::sr25519::vrf::VrfSignature; use sp_runtime::{DigestItem, RuntimeDebug}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// Raw BABE primary slot assignment pre-digest. @@ -139,7 +139,15 @@ pub struct NextEpochDescriptor { /// Information about the next epoch config, if changed. This is broadcast in the first /// block of the epoch, and applies using the same rules as `NextEpochDescriptor`. #[derive( - Decode, Encode, PartialEq, Eq, Clone, RuntimeDebug, MaxEncodedLen, scale_info::TypeInfo, + Decode, + DecodeWithMemTracking, + Encode, + PartialEq, + Eq, + Clone, + RuntimeDebug, + MaxEncodedLen, + scale_info::TypeInfo, )] pub enum NextConfigDescriptor { /// Version 1. diff --git a/substrate/primitives/consensus/babe/src/lib.rs b/substrate/primitives/consensus/babe/src/lib.rs index 163fbafa8dd4c..b29785b1c4463 100644 --- a/substrate/primitives/consensus/babe/src/lib.rs +++ b/substrate/primitives/consensus/babe/src/lib.rs @@ -27,7 +27,7 @@ pub mod inherents; #[cfg(not(feature = "std"))] use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; @@ -219,7 +219,18 @@ impl BabeConfiguration { } /// Types of allowed slots. -#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, RuntimeDebug, MaxEncodedLen, TypeInfo)] +#[derive( + Clone, + Copy, + PartialEq, + Eq, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + MaxEncodedLen, + TypeInfo, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub enum AllowedSlots { /// Only allow primary slots. diff --git a/substrate/primitives/consensus/beefy/src/commitment.rs b/substrate/primitives/consensus/beefy/src/commitment.rs index 5d4338aca10f9..49547ed877ecc 100644 --- a/substrate/primitives/consensus/beefy/src/commitment.rs +++ b/substrate/primitives/consensus/beefy/src/commitment.rs @@ -16,7 +16,7 @@ // limitations under the License. use alloc::{vec, vec::Vec}; -use codec::{Decode, Encode, Error, Input}; +use codec::{Decode, DecodeWithMemTracking, Encode, Error, Input}; use core::cmp; use scale_info::TypeInfo; use sp_application_crypto::RuntimeAppPublic; @@ -50,7 +50,7 @@ impl KnownSignature<&TAuthorityId, &TSig /// height [block_number](Commitment::block_number). /// GRANDPA validators collect signatures on commitments and a stream of such signed commitments /// (see [SignedCommitment]) forms the BEEFY protocol. -#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, TypeInfo)] +#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, TypeInfo)] pub struct Commitment { /// A collection of payloads to be signed, see [`Payload`] for details. /// diff --git a/substrate/primitives/consensus/beefy/src/lib.rs b/substrate/primitives/consensus/beefy/src/lib.rs index 0f57cdfc81042..40bf158df8746 100644 --- a/substrate/primitives/consensus/beefy/src/lib.rs +++ b/substrate/primitives/consensus/beefy/src/lib.rs @@ -47,7 +47,7 @@ pub use commitment::{Commitment, KnownSignature, SignedCommitment, VersionedFina pub use payload::{known_payloads, BeefyPayloadId, Payload, PayloadProvider}; use alloc::vec::Vec; -use codec::{Codec, Decode, Encode}; +use codec::{Codec, Decode, DecodeWithMemTracking, Encode}; use core::fmt::{Debug, Display}; use scale_info::TypeInfo; use sp_application_crypto::{AppPublic, RuntimeAppPublic}; @@ -298,7 +298,7 @@ pub enum ConsensusLog { /// A vote message is a direct vote created by a BEEFY node on every voting round /// and is gossiped to its peers. // TODO: Remove `Signature` generic type, instead get it from `Id::Signature`. -#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, TypeInfo)] pub struct VoteMessage { /// Commit to information extracted from a finalized block pub commitment: Commitment, @@ -313,7 +313,7 @@ pub struct VoteMessage { /// One type of misbehavior in BEEFY happens when an authority votes in the same round/block /// for different payloads. /// Proving is achieved by collecting the signed commitments of conflicting votes. -#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, TypeInfo)] pub struct DoubleVotingProof { /// The first vote in the equivocation. pub first: VoteMessage, @@ -340,7 +340,7 @@ impl DoubleVotingProof { /// /// Proving is achieved by providing a proof that contains relevant info about the canonical chain /// at `commitment.block_number`. The `commitment` can be checked against this info. -#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, TypeInfo)] pub struct ForkVotingProof { /// The equivocated vote. pub vote: VoteMessage, @@ -364,7 +364,7 @@ impl ForkVotingProof { /// The equivocated vote. pub vote: VoteMessage, diff --git a/substrate/primitives/consensus/beefy/src/payload.rs b/substrate/primitives/consensus/beefy/src/payload.rs index 2bc96548bdfff..82ca1ad21f024 100644 --- a/substrate/primitives/consensus/beefy/src/payload.rs +++ b/substrate/primitives/consensus/beefy/src/payload.rs @@ -16,7 +16,7 @@ // limitations under the License. use alloc::{vec, vec::Vec}; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use scale_info::TypeInfo; use sp_runtime::traits::Block; @@ -39,7 +39,19 @@ pub mod known_payloads { /// Identifiers MUST be sorted by the [`BeefyPayloadId`] to allow efficient lookup of expected /// value. Duplicated identifiers are disallowed. It's okay for different implementations to only /// support a subset of possible values. -#[derive(Decode, Encode, Debug, PartialEq, Eq, Clone, Ord, PartialOrd, Hash, TypeInfo)] +#[derive( + Decode, + DecodeWithMemTracking, + Encode, + Debug, + PartialEq, + Eq, + Clone, + Ord, + PartialOrd, + Hash, + TypeInfo, +)] pub struct Payload(Vec<(BeefyPayloadId, Vec)>); impl Payload { diff --git a/substrate/primitives/consensus/grandpa/src/lib.rs b/substrate/primitives/consensus/grandpa/src/lib.rs index d86ea0992c2e1..3aa4dc2b4cfb3 100644 --- a/substrate/primitives/consensus/grandpa/src/lib.rs +++ b/substrate/primitives/consensus/grandpa/src/lib.rs @@ -25,7 +25,7 @@ extern crate alloc; use serde::Serialize; use alloc::vec::Vec; -use codec::{Codec, Decode, Encode}; +use codec::{Codec, Decode, DecodeWithMemTracking, Encode}; use scale_info::TypeInfo; #[cfg(feature = "std")] use sp_keystore::KeystorePtr; @@ -231,7 +231,7 @@ impl ConsensusLog { /// GRANDPA happens when a voter votes on the same round (either at prevote or /// precommit stage) for different blocks. Proving is achieved by collecting the /// signed messages of conflicting votes. -#[derive(Clone, Debug, Decode, Encode, PartialEq, Eq, TypeInfo)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, Eq, TypeInfo)] pub struct EquivocationProof { set_id: SetId, equivocation: Equivocation, @@ -265,7 +265,7 @@ impl EquivocationProof { /// Wrapper object for GRANDPA equivocation proofs, useful for unifying prevote /// and precommit equivocations under a common type. -#[derive(Clone, Debug, Decode, Encode, PartialEq, Eq, TypeInfo)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, Eq, TypeInfo)] pub enum Equivocation { /// Proof of equivocation at prevote stage. Prevote( diff --git a/substrate/primitives/consensus/sassafras/src/lib.rs b/substrate/primitives/consensus/sassafras/src/lib.rs index d7880c4de9e8f..09baf678f16de 100644 --- a/substrate/primitives/consensus/sassafras/src/lib.rs +++ b/substrate/primitives/consensus/sassafras/src/lib.rs @@ -24,7 +24,7 @@ extern crate alloc; use alloc::vec::Vec; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use sp_core::crypto::KeyTypeId; use sp_runtime::{ConsensusEngineId, RuntimeDebug}; @@ -86,7 +86,17 @@ pub type Randomness = [u8; RANDOMNESS_LENGTH]; /// /// Mostly tweaks to the ticketing system parameters. #[derive( - Copy, Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, MaxEncodedLen, TypeInfo, Default, + Copy, + Clone, + PartialEq, + Eq, + Encode, + Decode, + DecodeWithMemTracking, + RuntimeDebug, + MaxEncodedLen, + TypeInfo, + Default, )] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct EpochConfiguration { diff --git a/substrate/primitives/consensus/sassafras/src/ticket.rs b/substrate/primitives/consensus/sassafras/src/ticket.rs index fd025f1d53eaf..1083530117cfe 100644 --- a/substrate/primitives/consensus/sassafras/src/ticket.rs +++ b/substrate/primitives/consensus/sassafras/src/ticket.rs @@ -18,7 +18,7 @@ //! Primitives related to tickets. use crate::vrf::RingVrfSignature; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; pub use sp_core::ed25519::{Public as EphemeralPublic, Signature as EphemeralSignature}; @@ -33,7 +33,9 @@ pub use sp_core::ed25519::{Public as EphemeralPublic, Signature as EphemeralSign pub type TicketId = u128; /// Ticket data persisted on-chain. -#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)] +#[derive( + Debug, Clone, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, MaxEncodedLen, TypeInfo, +)] pub struct TicketBody { /// Attempt index. pub attempt_idx: u32, @@ -47,7 +49,9 @@ pub struct TicketBody { pub type TicketSignature = RingVrfSignature; /// Ticket envelope used on during submission. -#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)] +#[derive( + Debug, Clone, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, MaxEncodedLen, TypeInfo, +)] pub struct TicketEnvelope { /// Ticket body. pub body: TicketBody, diff --git a/substrate/primitives/consensus/slots/src/lib.rs b/substrate/primitives/consensus/slots/src/lib.rs index dfa46fcf2571f..21f6f2e95b1bd 100644 --- a/substrate/primitives/consensus/slots/src/lib.rs +++ b/substrate/primitives/consensus/slots/src/lib.rs @@ -19,12 +19,25 @@ #![cfg_attr(not(feature = "std"), no_std)] -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use sp_timestamp::Timestamp; /// Unit type wrapper that represents a slot. -#[derive(Debug, Encode, MaxEncodedLen, Decode, Eq, Clone, Copy, Default, Ord, Hash, TypeInfo)] +#[derive( + Debug, + Encode, + MaxEncodedLen, + Decode, + DecodeWithMemTracking, + Eq, + Clone, + Copy, + Default, + Ord, + Hash, + TypeInfo, +)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[repr(transparent)] pub struct Slot(u64); @@ -172,7 +185,7 @@ impl SlotDuration { /// produces more than one block on the same slot. The proof of equivocation /// are the given distinct headers that were signed by the validator and which /// include the slot number. -#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo, Eq)] +#[derive(Clone, Debug, Decode, DecodeWithMemTracking, Encode, PartialEq, TypeInfo, Eq)] pub struct EquivocationProof { /// Returns the authority id of the equivocator. pub offender: Id, diff --git a/substrate/primitives/core/src/bandersnatch.rs b/substrate/primitives/core/src/bandersnatch.rs index 25bf4657030fb..2a97e3e79d56b 100644 --- a/substrate/primitives/core/src/bandersnatch.rs +++ b/substrate/primitives/core/src/bandersnatch.rs @@ -28,7 +28,7 @@ use crate::crypto::{ }; use bandersnatch_vrfs::{CanonicalSerialize, SecretKey}; -use codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, EncodeLike, MaxEncodedLen}; use scale_info::TypeInfo; use alloc::{vec, vec::Vec}; @@ -657,7 +657,9 @@ pub mod ring_vrf { } /// Ring VRF signature. - #[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)] + #[derive( + Clone, Debug, PartialEq, Eq, Encode, Decode, DecodeWithMemTracking, MaxEncodedLen, TypeInfo, + )] pub struct RingVrfSignature { /// Ring signature. pub signature: [u8; RING_SIGNATURE_SERIALIZED_SIZE], diff --git a/substrate/primitives/merkle-mountain-range/src/lib.rs b/substrate/primitives/merkle-mountain-range/src/lib.rs index 061e5dbb6c7d8..53158476cf107 100644 --- a/substrate/primitives/merkle-mountain-range/src/lib.rs +++ b/substrate/primitives/merkle-mountain-range/src/lib.rs @@ -26,6 +26,7 @@ pub use mmr_lib; #[cfg(not(feature = "std"))] use alloc::vec::Vec; +use codec::{Decode, DecodeWithMemTracking, Encode}; use core::fmt; use scale_info::TypeInfo; use sp_debug_derive::RuntimeDebug; @@ -362,7 +363,7 @@ pub struct LeafProof { } /// An MMR ancestry proof for a prior mmr root. -#[derive(codec::Encode, codec::Decode, RuntimeDebug, Clone, PartialEq, Eq, TypeInfo)] +#[derive(Encode, Decode, DecodeWithMemTracking, RuntimeDebug, Clone, PartialEq, Eq, TypeInfo)] pub struct AncestryProof { /// Peaks of the ancestor's mmr pub prev_peaks: Vec, diff --git a/substrate/primitives/npos-elections/src/lib.rs b/substrate/primitives/npos-elections/src/lib.rs index 12d4c5948ed9c..6fcdd38d40107 100644 --- a/substrate/primitives/npos-elections/src/lib.rs +++ b/substrate/primitives/npos-elections/src/lib.rs @@ -77,7 +77,7 @@ extern crate alloc; use alloc::{collections::btree_map::BTreeMap, rc::Rc, vec, vec::Vec}; -use codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, DecodeWithMemTracking, Encode, MaxEncodedLen}; use core::{cell::RefCell, cmp::Ordering}; use scale_info::TypeInfo; #[cfg(feature = "serde")] @@ -111,7 +111,14 @@ pub use traits::{IdentifierT, PerThing128}; /// The errors that might occur in this crate and `frame-election-provider-solution-type`. #[derive( - Eq, PartialEq, RuntimeDebug, Clone, codec::Encode, codec::Decode, scale_info::TypeInfo, + Eq, + PartialEq, + RuntimeDebug, + Clone, + codec::Encode, + codec::Decode, + codec::DecodeWithMemTracking, + scale_info::TypeInfo, )] pub enum Error { /// While going from solution indices to ratio, the weight of all the edges has gone above the @@ -147,7 +154,19 @@ pub type ExtendedBalance = u128; /// 1. `minimal_stake`. /// 2. `sum_stake`. /// 3. `sum_stake_squared`. -#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo, Debug, Default)] +#[derive( + Clone, + Copy, + PartialEq, + Eq, + Encode, + Decode, + DecodeWithMemTracking, + MaxEncodedLen, + TypeInfo, + Debug, + Default, +)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct ElectionScore { /// The minimal winner, in terms of total backing stake. @@ -433,7 +452,7 @@ pub struct ElectionResult { /// /// This, at the current version, resembles the `Exposure` defined in the Staking pallet, yet they /// do not necessarily have to be the same. -#[derive(RuntimeDebug, Encode, Decode, Clone, Eq, PartialEq, TypeInfo)] +#[derive(RuntimeDebug, Encode, Decode, DecodeWithMemTracking, Clone, Eq, PartialEq, TypeInfo)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] pub struct Support { /// Total support. diff --git a/substrate/primitives/session/src/lib.rs b/substrate/primitives/session/src/lib.rs index fe7a38047338d..3225097b665e6 100644 --- a/substrate/primitives/session/src/lib.rs +++ b/substrate/primitives/session/src/lib.rs @@ -21,7 +21,7 @@ extern crate alloc; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; #[cfg(feature = "std")] use sp_api::ProvideRuntimeApi; @@ -39,7 +39,17 @@ pub use runtime_api::*; pub type ValidatorCount = u32; /// Proof of membership of a specific key in a given session. -#[derive(Encode, Decode, Clone, Eq, PartialEq, Default, RuntimeDebug, scale_info::TypeInfo)] +#[derive( + Encode, + Decode, + DecodeWithMemTracking, + Clone, + Eq, + PartialEq, + Default, + RuntimeDebug, + scale_info::TypeInfo, +)] pub struct MembershipProof { /// The session index on which the specific key is a member. pub session: SessionIndex, diff --git a/substrate/primitives/statement-store/src/lib.rs b/substrate/primitives/statement-store/src/lib.rs index dbac017ff6493..d765ddad3ed8c 100644 --- a/substrate/primitives/statement-store/src/lib.rs +++ b/substrate/primitives/statement-store/src/lib.rs @@ -23,7 +23,7 @@ extern crate alloc; use alloc::vec::Vec; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use scale_info::TypeInfo; use sp_application_crypto::RuntimeAppPublic; #[cfg(feature = "std")] @@ -93,7 +93,9 @@ pub fn hash_encoded(data: &[u8]) -> [u8; 32] { } /// Statement proof. -#[derive(Encode, Decode, TypeInfo, sp_core::RuntimeDebug, Clone, PartialEq, Eq)] +#[derive( + Encode, Decode, DecodeWithMemTracking, TypeInfo, sp_core::RuntimeDebug, Clone, PartialEq, Eq, +)] pub enum Proof { /// Sr25519 Signature. Sr25519 { @@ -174,7 +176,16 @@ impl Field { } /// Statement structure. -#[derive(TypeInfo, sp_core::RuntimeDebug, PassByCodec, Clone, PartialEq, Eq, Default)] +#[derive( + DecodeWithMemTracking, + TypeInfo, + sp_core::RuntimeDebug, + PassByCodec, + Clone, + PartialEq, + Eq, + Default, +)] pub struct Statement { proof: Option, decryption_key: Option, diff --git a/substrate/primitives/transaction-storage-proof/src/lib.rs b/substrate/primitives/transaction-storage-proof/src/lib.rs index 893b2e33bee6c..52a8703cf6e73 100644 --- a/substrate/primitives/transaction-storage-proof/src/lib.rs +++ b/substrate/primitives/transaction-storage-proof/src/lib.rs @@ -25,7 +25,7 @@ extern crate alloc; use core::result::Result; use alloc::vec::Vec; -use codec::{Decode, Encode}; +use codec::{Decode, DecodeWithMemTracking, Encode}; use sp_inherents::{InherentData, InherentIdentifier, IsFatalError}; use sp_runtime::traits::{Block as BlockT, NumberFor}; @@ -54,7 +54,7 @@ impl IsFatalError for InherentError { /// Holds a chunk of data retrieved from storage along with /// a proof that the data was stored at that location in the trie. -#[derive(Encode, Decode, Clone, PartialEq, Debug, scale_info::TypeInfo)] +#[derive(Encode, Decode, DecodeWithMemTracking, Clone, PartialEq, Debug, scale_info::TypeInfo)] pub struct TransactionStorageProof { /// Data chunk that is proved to exist. pub chunk: Vec, From a41aed0cc0b5235a66e1bf4b78456822a9e402a8 Mon Sep 17 00:00:00 2001 From: Serban Iorga Date: Mon, 17 Feb 2025 19:56:53 +0200 Subject: [PATCH 3/5] impl DecodeWithMemTracking for pallet-nfts structs --- substrate/frame/nfts/src/types.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/substrate/frame/nfts/src/types.rs b/substrate/frame/nfts/src/types.rs index d606ecb0e6400..b263cc0b9f16b 100644 --- a/substrate/frame/nfts/src/types.rs +++ b/substrate/frame/nfts/src/types.rs @@ -20,7 +20,7 @@ use super::*; use crate::macros::*; use alloc::{vec, vec::Vec}; -use codec::EncodeLike; +use codec::{DecodeWithMemTracking, EncodeLike}; use enumflags2::{bitflags, BitFlags}; use frame_support::{ pallet_prelude::{BoundedVec, MaxEncodedLen}, @@ -332,6 +332,9 @@ impl CollectionSettings { } impl_codec_bitflags!(CollectionSettings, u64, CollectionSetting); +// We can implement `DecodeWithMemTracking` for `CollectionSettings` +// since `u64` also implements `DecodeWithMemTracking`. +impl DecodeWithMemTracking for CollectionSettings {} /// Mint type. Can the NFT be create by anyone, or only the creator of the collection, /// or only by wallets that already hold an NFT from a certain collection? @@ -514,6 +517,9 @@ impl ItemSettings { } impl_codec_bitflags!(ItemSettings, u64, ItemSetting); +// We can implement `DecodeWithMemTracking` for `ItemSettings` +// since `u64` also implements `DecodeWithMemTracking`. +impl DecodeWithMemTracking for ItemSettings {} /// Item's configuration. #[derive( From 2bb0a0d493a122d0ec1b2ca7c80140090d96b42a Mon Sep 17 00:00:00 2001 From: Serban Iorga Date: Tue, 18 Feb 2025 09:50:43 +0200 Subject: [PATCH 4/5] impl DecodeWithMemTracking for VrfPreOutput --- substrate/primitives/core/src/bandersnatch.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/substrate/primitives/core/src/bandersnatch.rs b/substrate/primitives/core/src/bandersnatch.rs index 2a97e3e79d56b..22b371578e11a 100644 --- a/substrate/primitives/core/src/bandersnatch.rs +++ b/substrate/primitives/core/src/bandersnatch.rs @@ -227,6 +227,22 @@ pub mod vrf { } } + /// `VrfPreOutput` resolves to: + /// ``` + /// pub struct Affine { + /// #[doc(hidden)] + /// pub x: P::BaseField, + /// #[doc(hidden)] + /// pub y: P::BaseField, + /// #[doc(hidden)] + /// pub infinity: bool, + /// } + /// ``` + /// where each `P::BaseField` contains a `pub struct BigInt(pub [u64; N]);` + /// Since none of these structures is allocated on the heap, we don't need any special + /// memory tracking logic. We can simply implement `DecodeWithMemTracking`. + impl DecodeWithMemTracking for VrfPreOutput {} + impl EncodeLike for VrfPreOutput {} impl MaxEncodedLen for VrfPreOutput { From 4091e26da68ee26356309a7e70411e9663bbc17e Mon Sep 17 00:00:00 2001 From: Serban Iorga Date: Tue, 18 Feb 2025 12:53:44 +0200 Subject: [PATCH 5/5] Fix test-doc --- substrate/primitives/core/src/bandersnatch.rs | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/substrate/primitives/core/src/bandersnatch.rs b/substrate/primitives/core/src/bandersnatch.rs index 22b371578e11a..0ede8119ce3d9 100644 --- a/substrate/primitives/core/src/bandersnatch.rs +++ b/substrate/primitives/core/src/bandersnatch.rs @@ -227,20 +227,20 @@ pub mod vrf { } } - /// `VrfPreOutput` resolves to: - /// ``` - /// pub struct Affine { - /// #[doc(hidden)] - /// pub x: P::BaseField, - /// #[doc(hidden)] - /// pub y: P::BaseField, - /// #[doc(hidden)] - /// pub infinity: bool, - /// } - /// ``` - /// where each `P::BaseField` contains a `pub struct BigInt(pub [u64; N]);` - /// Since none of these structures is allocated on the heap, we don't need any special - /// memory tracking logic. We can simply implement `DecodeWithMemTracking`. + // `VrfPreOutput` resolves to: + // ``` + // pub struct Affine { + // #[doc(hidden)] + // pub x: P::BaseField, + // #[doc(hidden)] + // pub y: P::BaseField, + // #[doc(hidden)] + // pub infinity: bool, + // } + // ``` + // where each `P::BaseField` contains a `pub struct BigInt(pub [u64; N]);` + // Since none of these structures is allocated on the heap, we don't need any special + // memory tracking logic. We can simply implement `DecodeWithMemTracking`. impl DecodeWithMemTracking for VrfPreOutput {} impl EncodeLike for VrfPreOutput {}