Upgrade Polkadot-v1.6.0

• benchmarking v1 to v2.
• Replace GenesisBuilder.
• Upgrade cucumber cli.
• Upgrade workspace.

pallets/provide-randomness/src/benchmarking.rs

@@ -18,7 +18,8 @@
 
 use super::*;
 
-use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_benchmarking::v2::*;
+use frame_benchmarking::whitelisted_caller;
 use frame_support::ensure;
 use frame_support::pallet_prelude::IsType;
 use frame_support::sp_runtime::{traits::One, Saturating};
@@ -29,49 +30,51 @@ use sp_core::H256;
 
 use crate::Pallet;
 
-fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
-    frame_system::Pallet::<T>::assert_has_event(generic_event.into());
-}
+#[benchmarks(
+        where
+        T: pallet_balances::Config,
+        T::Balance: From<u64>,
+        <T::Currency as Currency<T::AccountId>>::Balance: IsType<T::Balance>,
+        BlockNumberFor<T>: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
 
-fn add_requests_next_block<T: Config>(i: u32) -> Result<(), &'static str> {
-    for _ in 0..i {
-        let salt: H256 = H256([0; 32]);
-        let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
-            core::mem::replace(next_request_id, next_request_id.saturating_add(1))
-        });
-        RequestsIds::<T>::insert(request_id, ());
-        RequestsReadyAtNextBlock::<T>::append(Request { request_id, salt });
+    fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+        frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
-    Ok(())
-}
 
-fn add_requests_next_epoch<T: Config>(i: u32) -> Result<(), &'static str> {
-    for _ in 0..i {
-        let salt: H256 = H256([0; 32]);
-        let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
-            core::mem::replace(next_request_id, next_request_id.saturating_add(1))
-        });
-        RequestsIds::<T>::insert(request_id, ());
-        RequestsReadyAtEpoch::<T>::append(
-            T::GetCurrentEpochIndex::get(),
-            Request { request_id, salt },
-        );
+    fn add_requests_next_block<T: Config>(i: u32) -> Result<(), &'static str> {
+        for _ in 0..i {
+            let salt: H256 = H256([0; 32]);
+            let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
+                core::mem::replace(next_request_id, next_request_id.saturating_add(1))
+            });
+            RequestsIds::<T>::insert(request_id, ());
+            RequestsReadyAtNextBlock::<T>::append(Request { request_id, salt });
+        }
+        Ok(())
     }
-    Ok(())
-}
 
-benchmarks! {
-    where_clause { where
-        T: pallet_balances::Config,
-        T::Balance: From<u64>,
-        <T::Currency as Currency<T::AccountId>>::Balance: IsType<T::Balance>,
-        BlockNumberFor<T>: From<u32>,
+    fn add_requests_next_epoch<T: Config>(i: u32) -> Result<(), &'static str> {
+        for _ in 0..i {
+            let salt: H256 = H256([0; 32]);
+            let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
+                core::mem::replace(next_request_id, next_request_id.saturating_add(1))
+            });
+            RequestsIds::<T>::insert(request_id, ());
+            RequestsReadyAtEpoch::<T>::append(
+                T::GetCurrentEpochIndex::get(),
+                Request { request_id, salt },
+            );
+        }
+        Ok(())
     }
-    request {
+
+    #[benchmark]
+    fn request() {
         // Get account
         let caller: T::AccountId = whitelisted_caller();
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
-            RawOrigin::Signed(caller.clone()).into();
 
         // Provide deposit
         let existential_deposit = T::ExistentialDeposit::get();
@@ -81,36 +84,71 @@ benchmarks! {
         // Set randomness parameters
         let random = RandomnessType::RandomnessFromOneEpochAgo;
         let salt: H256 = H256([1; 32]);
-    }: _<T::RuntimeOrigin>(caller_origin.clone(), random, salt)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), random, salt);
+
         let request_id = RequestIdProvider::<T>::get() - 1;
-        assert_has_event::<T>(Event::RequestedRandomness {
-              request_id, salt, r#type: random }.into() );
+        assert_has_event::<T>(
+            Event::RequestedRandomness {
+                request_id,
+                salt,
+                r#type: random,
+            }
+            .into(),
+        );
     }
-    on_initialize {
-        let i in 1 .. T::MaxRequests::get() => add_requests_next_block::<T>(i)?;
+
+    #[benchmark]
+    fn on_initialize(i: Linear<1, { T::MaxRequests::get() }>) -> Result<(), BenchmarkError> {
+        add_requests_next_block::<T>(i)?;
         ensure!(RequestsIds::<T>::count() == i, "List not filled properly.");
-        ensure!(RequestsReadyAtNextBlock::<T>::get().len() == i as usize, "List not filled properly.");
+        ensure!(
+            RequestsReadyAtNextBlock::<T>::get().len() == i as usize,
+            "List not filled properly."
+        );
         let next_epoch_hook_in = NexEpochHookIn::<T>::mutate(|next_in| {
             core::mem::replace(next_in, next_in.saturating_sub(1))
         });
         ensure!(next_epoch_hook_in != 1, "Will be next epoch.");
-    }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
-    verify {
+
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
+        }
+
         ensure!(RequestsIds::<T>::count() == 0, "List not processed.");
-        ensure!(RequestsReadyAtNextBlock::<T>::get().is_empty(), "List not processed.");
+        ensure!(
+            RequestsReadyAtNextBlock::<T>::get().is_empty(),
+            "List not processed."
+        );
+        Ok(())
     }
-    on_initialize_epoch {
-        let i in 1 .. T::MaxRequests::get() => add_requests_next_epoch::<T>(i)?;
-        ensure!(RequestsReadyAtNextBlock::<T>::get().is_empty(), "List not filled properly.");
+
+    #[benchmark]
+    fn on_initialize_epoch(i: Linear<1, { T::MaxRequests::get() }>) -> Result<(), BenchmarkError> {
+        add_requests_next_epoch::<T>(i)?;
+        ensure!(
+            RequestsReadyAtNextBlock::<T>::get().is_empty(),
+            "List not filled properly."
+        );
         ensure!(RequestsIds::<T>::count() == i, "List not filled properly.");
-        ensure!(RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).len() == i as usize, "List not filled properly.");
-        let next_epoch_hook_in = NexEpochHookIn::<T>::mutate(|next_in| {
-            core::mem::replace(next_in, 1)
-        });
-    }: { Pallet::<T>::on_initialize(1.into()); }
-    verify {
+        ensure!(
+            RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).len() == i as usize,
+            "List not filled properly."
+        );
+        NexEpochHookIn::<T>::mutate(|next_in| core::mem::replace(next_in, 1));
+
+        #[block]
+        {
+            Pallet::<T>::on_initialize(1.into());
+        }
+
         ensure!(RequestsIds::<T>::count() == 0, "List not processed.");
-        ensure!(RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).is_empty(), "List not processed properly.");
+        ensure!(
+            RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).is_empty(),
+            "List not processed properly."
+        );
+        Ok(())
     }
 }