Update pallet-benchmarking

.snippets/code/Cargo.toml

@@ -14,6 +14,7 @@ members = [
   "tutorials/polkadot-sdk/parachains/zero-to-hero/build-custom-pallet",
   "tutorials/polkadot-sdk/parachains/zero-to-hero/pallet-unit-testing",
   "tutorials/polkadot-sdk/parachains/zero-to-hero/add-pallets-to-runtime/runtime",
+  "tutorials/polkadot-sdk/parachains/zero-to-hero/pallet-benchmarking/runtime",
 ]
 resolver = "2"
 

.snippets/code/tutorials/polkadot-sdk/parachains/zero-to-hero/pallet-benchmarking/pallets/custom-pallet/src/lib.rs

@@ -0,0 +1,199 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub mod weights;
+use crate::weights::WeightInfo;
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    // Configuration trait for the pallet.
+    #[pallet::config]
+    pub trait Config: frame_system::Config {
+        // Defines the event type for the pallet.
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        // Defines the maximum value the counter can hold.
+        #[pallet::constant]
+        type CounterMaxValue: Get<u32>;
+
+        /// A type representing the weights required by the dispatchables of this pallet.
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        /// The counter value has been set to a new value by Root.
+        CounterValueSet {
+            /// The new value set.
+            counter_value: u32,
+        },
+        /// A user has successfully incremented the counter.
+        CounterIncremented {
+            /// The new value set.
+            counter_value: u32,
+            /// The account who incremented the counter.
+            who: T::AccountId,
+            /// The amount by which the counter was incremented.
+            incremented_amount: u32,
+        },
+        /// A user has successfully decremented the counter.
+        CounterDecremented {
+            /// The new value set.
+            counter_value: u32,
+            /// The account who decremented the counter.
+            who: T::AccountId,
+            /// The amount by which the counter was decremented.
+            decremented_amount: u32,
+        },
+    }
+
+    /// Storage for the current value of the counter.
+    #[pallet::storage]
+    pub type CounterValue<T> = StorageValue<_, u32>;
+
+    /// Storage map to track the number of interactions performed by each account.
+    #[pallet::storage]
+    pub type UserInteractions<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, u32>;
+
+    #[pallet::error]
+    pub enum Error<T> {
+        /// The counter value exceeds the maximum allowed value.
+        CounterValueExceedsMax,
+        /// The counter value cannot be decremented below zero.
+        CounterValueBelowZero,
+        /// Overflow occurred in the counter.
+        CounterOverflow,
+        /// Overflow occurred in user interactions.
+        UserInteractionOverflow,
+    }
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        /// Set the value of the counter.
+        ///
+        /// The dispatch origin of this call must be _Root_.
+        ///
+        /// - `new_value`: The new value to set for the counter.
+        ///
+        /// Emits `CounterValueSet` event when successful.
+        #[pallet::call_index(0)]
+        #[pallet::weight(T::WeightInfo::set_counter_value())]
+        pub fn set_counter_value(origin: OriginFor<T>, new_value: u32) -> DispatchResult {
+            ensure_root(origin)?;
+
+            ensure!(
+                new_value <= T::CounterMaxValue::get(),
+                Error::<T>::CounterValueExceedsMax
+            );
+
+            CounterValue::<T>::put(new_value);
+
+            Self::deposit_event(Event::<T>::CounterValueSet {
+                counter_value: new_value,
+            });
+
+            Ok(())
+        }
+
+        /// Increment the counter by a specified amount.
+        ///
+        /// This function can be called by any signed account.
+        ///
+        /// - `amount_to_increment`: The amount by which to increment the counter.
+        ///
+        /// Emits `CounterIncremented` event when successful.
+        #[pallet::call_index(1)]
+        #[pallet::weight(T::WeightInfo::increment())]
+        pub fn increment(origin: OriginFor<T>, amount_to_increment: u32) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+
+            let current_value = CounterValue::<T>::get().unwrap_or(0);
+
+            let new_value = current_value
+                .checked_add(amount_to_increment)
+                .ok_or(Error::<T>::CounterOverflow)?;
+
+            ensure!(
+                new_value <= T::CounterMaxValue::get(),
+                Error::<T>::CounterValueExceedsMax
+            );
+
+            CounterValue::<T>::put(new_value);
+
+            UserInteractions::<T>::try_mutate(&who, |interactions| -> Result<_, Error<T>> {
+                let new_interactions = interactions
+                    .unwrap_or(0)
+                    .checked_add(1)
+                    .ok_or(Error::<T>::UserInteractionOverflow)?;
+                *interactions = Some(new_interactions); // Store the new value.
+
+                Ok(())
+            })?;
+
+            Self::deposit_event(Event::<T>::CounterIncremented {
+                counter_value: new_value,
+                who,
+                incremented_amount: amount_to_increment,
+            });
+
+            Ok(())
+        }
+
+        /// Decrement the counter by a specified amount.
+        ///
+        /// This function can be called by any signed account.
+        ///
+        /// - `amount_to_decrement`: The amount by which to decrement the counter.
+        ///
+        /// Emits `CounterDecremented` event when successful.
+        #[pallet::call_index(2)]
+        #[pallet::weight(T::WeightInfo::decrement())]
+        pub fn decrement(origin: OriginFor<T>, amount_to_decrement: u32) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+
+            let current_value = CounterValue::<T>::get().unwrap_or(0);
+
+            let new_value = current_value
+                .checked_sub(amount_to_decrement)
+                .ok_or(Error::<T>::CounterValueBelowZero)?;
+
+            CounterValue::<T>::put(new_value);
+
+            UserInteractions::<T>::try_mutate(&who, |interactions| -> Result<_, Error<T>> {
+                let new_interactions = interactions
+                    .unwrap_or(0)
+                    .checked_add(1)
+                    .ok_or(Error::<T>::UserInteractionOverflow)?;
+                *interactions = Some(new_interactions); // Store the new value.
+
+                Ok(())
+            })?;
+
+            Self::deposit_event(Event::<T>::CounterDecremented {
+                counter_value: new_value,
+                who,
+                decremented_amount: amount_to_decrement,
+            });
+
+            Ok(())
+        }
+    }
+}

.snippets/code/tutorials/polkadot-sdk/parachains/zero-to-hero/pallet-benchmarking/mock.rs → .snippets/code/tutorials/polkadot-sdk/parachains/zero-to-hero/pallet-benchmarking/pallets/custom-pallet/src/mock.rs

@@ -1,4 +1,4 @@
-use crate as custom_pallet;
+use crate as pallet_custom;
 use frame_support::{derive_impl, parameter_types};
 use sp_runtime::BuildStorage;
 
@@ -22,9 +22,9 @@ mod runtime {
 
     #[runtime::pallet_index(0)]
     pub type System = frame_system::Pallet<Test>;
-
+    
     #[runtime::pallet_index(1)]
-    pub type CustomPallet = custom_pallet::Pallet<Test>;
+    pub type CustomPallet = pallet_custom::Pallet<Test>;
 }
 
 // System pallet configuration
@@ -33,18 +33,17 @@ impl frame_system::Config for Test {
     type Block = Block;
 }
 
-// Custom pallet configuration.
+// Custom pallet configuration
 parameter_types! {
     pub const CounterMaxValue: u32 = 10;
 }
 
-impl custom_pallet::Config for Test {
+impl pallet_custom::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type CounterMaxValue = CounterMaxValue;
-    type WeightInfo = custom_pallet::weights::SubstrateWeight<Test>;
 }
 
-// Test externalities initialization.
+// Test externalities initialization
 pub fn new_test_ext() -> sp_io::TestExternalities {
     frame_system::GenesisConfig::<Test>::default()
         .build_storage()