update to benchmarking v2

pallets/authority-members/src/benchmarking.rs

@@ -17,70 +17,83 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
+use crate::Pallet;
 
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
 
-use crate::Pallet;
+#[benchmarks(
+        where
+            <T as Config>::MemberId: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
 
     fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
         frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
 
-benchmarks! {
-    where_clause {
-        where
-            T::MemberId: From<u32>,
-    }
-    go_offline {
+    #[benchmark]
+    fn go_offline() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         let caller: T::AccountId = Members::<T>::get(id).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-    }: _<T::RuntimeOrigin>(caller_origin)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller));
+
         assert_has_event::<T>(Event::<T>::MemberGoOffline { member: id }.into());
     }
-     go_online {
+
+    #[benchmark]
+    fn go_online() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         let caller: T::AccountId = Members::<T>::get(id).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
         OnlineAuthorities::<T>::mutate(|ids| {
             ids.retain(|&x| x != id);
         });
         OutgoingAuthorities::<T>::mutate(|ids| {
             ids.retain(|&x| x != id);
         });
-    }: _<T::RuntimeOrigin>(caller_origin)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller));
+
         assert_has_event::<T>(Event::<T>::MemberGoOnline { member: id }.into());
     }
-     set_session_keys {
+
+    #[benchmark]
+    fn set_session_keys() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         let caller: T::AccountId = Members::<T>::get(id).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
         let validator_id = T::ValidatorIdOf::convert(caller.clone()).unwrap();
         let session_keys: T::Keys = pallet_session::NextKeys::<T>::get(validator_id).unwrap();
-        }: _<T::RuntimeOrigin>(caller_origin, session_keys)
-     remove_member {
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), session_keys);
+    }
+
+    #[benchmark]
+    fn remove_member() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
-        let caller_origin = RawOrigin::Root.into();
-        }: _<T::RuntimeOrigin>(caller_origin, id)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, id);
+
         assert_has_event::<T>(Event::<T>::MemberRemoved { member: id }.into());
     }
-     remove_member_from_blacklist {
+
+    #[benchmark]
+    fn remove_member_from_blacklist() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         Blacklist::<T>::mutate(|blacklist| {
             blacklist.push(id);
         });
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), id)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, id);
+
         assert_has_event::<T>(Event::<T>::MemberRemovedFromBlacklist { member: id }.into());
     }
 
-     impl_benchmark_test_suite!(
-            Pallet,
-            crate::mock::new_test_ext(2),
-            crate::mock::Test
-        );
+    impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(2), crate::mock::Test);
 }

pallets/certification/src/benchmarking.rs

@@ -18,15 +18,19 @@
 
 use super::*;
 
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Zero;
 
-#[cfg(test)]
-use maplit::btreemap;
-
 use crate::Pallet;
 
+#[benchmarks(
+        where
+            <T as Config>::IdtyIndex: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
+
     fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
         frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
@@ -43,93 +47,127 @@ fn add_certs<T: Config>(i: u32, receiver: T::IdtyIndex) -> Result<(), &'static s
         Ok(())
     }
 
-benchmarks! {
-    where_clause {
-        where
-            T::IdtyIndex: From<u32>,
-    }
-    add_cert {
+    #[benchmark]
+    fn add_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
         let caller: T::AccountId = T::IdtyAttr::owner_key(issuer).unwrap();
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
         let receiver: T::IdtyIndex = 2.into();
         Pallet::<T>::del_cert(RawOrigin::Root.into(), issuer, receiver)?;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
         frame_system::pallet::Pallet::<T>::set_block_number(T::CertPeriod::get());
-    }: _<T::RuntimeOrigin>(caller_origin, receiver)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), receiver);
+
         assert_has_event::<T>(Event::<T>::CertAdded { issuer, receiver }.into());
+        Ok(())
     }
 
-    renew_cert {
+    #[benchmark]
+    fn renew_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
         let caller: T::AccountId = T::IdtyAttr::owner_key(issuer).unwrap();
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
         let receiver: T::IdtyIndex = 2.into();
         Pallet::<T>::del_cert(RawOrigin::Root.into(), issuer, receiver)?;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
         frame_system::pallet::Pallet::<T>::set_block_number(T::CertPeriod::get());
-        Pallet::<T>::add_cert(caller_origin.clone(), receiver)?;
-        frame_system::pallet::Pallet::<T>::set_block_number(T::CertPeriod::get() + T::CertPeriod::get());
-    }: _<T::RuntimeOrigin>(caller_origin, receiver)
-    verify {
+        Pallet::<T>::add_cert(RawOrigin::Signed(caller.clone()).into(), receiver)?;
+        frame_system::pallet::Pallet::<T>::set_block_number(
+            T::CertPeriod::get() + T::CertPeriod::get(),
+        );
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), receiver);
+
         assert_has_event::<T>(Event::<T>::CertAdded { issuer, receiver }.into());
+        Ok(())
     }
 
-    del_cert {
+    #[benchmark]
+    fn del_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
         let receiver: T::IdtyIndex = 2.into();
         // try to add cert if missing, else ignore
         // this depends on initial data
         let _ = Pallet::<T>::do_add_cert_checked(issuer, receiver, false);
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), issuer, receiver)
-    verify {
-        assert_has_event::<T>(Event::<T>::CertRemoved{ issuer,  receiver, expiration: false }.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, issuer, receiver);
+
+        assert_has_event::<T>(
+            Event::<T>::CertRemoved {
+                issuer,
+                receiver,
+                expiration: false,
+            }
+            .into(),
+        );
+        Ok(())
     }
 
-    remove_all_certs_received_by {
+    #[benchmark]
+    fn remove_all_certs_received_by(i: Linear<2, 1_000>) -> Result<(), BenchmarkError> {
         let receiver: T::IdtyIndex = 0.into();
-        let i in 2..1000 => add_certs::<T>(i, receiver)?;
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(),  receiver)
-    verify {
+        add_certs::<T>(i, receiver)?;
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, receiver);
+
         assert!(CertsByReceiver::<T>::get(receiver).is_empty());
+        Ok(())
     }
 
-    on_initialize {
+    #[benchmark]
+    fn on_initialize() {
         assert!(CertsRemovableOn::<T>::try_get(BlockNumberFor::<T>::zero()).is_err());
-    }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
 
-    do_remove_cert_noop {
-    }: {Pallet::<T>::do_remove_cert(100.into(), 101.into(), Some(BlockNumberFor::<T>::zero()));}
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
+        }
+    }
+
+    #[benchmark]
+    fn do_remove_cert_noop() {
+        #[block]
+        {
+            Pallet::<T>::do_remove_cert(100.into(), 101.into(), Some(BlockNumberFor::<T>::zero()));
+        }
+    }
 
-    do_remove_cert {
+    #[benchmark]
+    fn do_remove_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
         let receiver: T::IdtyIndex = 0.into();
         Pallet::<T>::do_remove_cert(issuer, receiver, None);
         Pallet::<T>::do_add_cert_checked(issuer, receiver, false)?;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
         let block_number = T::ValidityPeriod::get();
         frame_system::pallet::Pallet::<T>::set_block_number(block_number);
-    }: {Pallet::<T>::do_remove_cert(issuer, receiver, Some(block_number));}
-    verify {
-        assert_has_event::<T>(Event::<T>::CertRemoved{ issuer,  receiver, expiration: true }.into());
+
+        #[block]
+        {
+            Pallet::<T>::do_remove_cert(issuer, receiver, Some(block_number));
+        }
+
+        assert_has_event::<T>(
+            Event::<T>::CertRemoved {
+                issuer,
+                receiver,
+                expiration: true,
+            }
+            .into(),
+        );
+        Ok(())
     }
 
     impl_benchmark_test_suite!(
         Pallet,
         crate::mock::new_test_ext(crate::mock::DefaultCertificationConfig {
             apply_cert_period_at_genesis: true,
-        certs_by_receiver: btreemap![
-                0 => btreemap![
+            certs_by_receiver: maplit::btreemap![
+                0 => maplit::btreemap![
                     1 => Some(7),
                     2 => Some(9),
                 ],
-                1 => btreemap![
+                1 => maplit::btreemap![
                     0 => Some(10),
                     2 => Some(3),
                 ],

pallets/distance/src/benchmarking.rs

@@ -19,7 +19,7 @@
 use super::*;
 
 use codec::Encode;
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_support::traits::{Currency, OnFinalize};
 use frame_system::pallet_prelude::BlockNumberFor;
 use frame_system::RawOrigin;
@@ -29,6 +29,15 @@ use sp_runtime::Perbill;
 
 use crate::Pallet;
 
+#[benchmarks(
+        where
+        T: pallet_balances::Config,
+		T::Balance: From<u64>,
+        BlockNumberFor<T>: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
+
     fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
         frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
@@ -45,76 +54,125 @@ fn populate_pool<T: Config>(i: u32) -> Result<(), &'static str> {
         })
     }
 
-benchmarks! {
-    where_clause {
-        where
-        T: pallet_balances::Config, T::Balance: From<u64>,
-        BlockNumberFor<T>: From<u32>,
-    }
-
-    // request distance evaluation
-    request_distance_evaluation {
+    #[benchmark]
+    fn request_distance_evaluation() {
         let idty = T::IdtyIndex::one();
-        let caller: T::AccountId  = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-        let _ = <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
-    }: _<T::RuntimeOrigin>(caller_origin.clone())
-    verify {
-        assert!(PendingEvaluationRequest::<T>::get(idty) == Some(caller.clone()), "Request not added");
-        assert_has_event::<T>(Event::<T>::EvaluationRequested { idty_index: idty, who: caller }.into());
+        let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty)
+            .unwrap()
+            .owner_key;
+        let _ =
+            <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller.clone()));
+
+        assert!(
+            PendingEvaluationRequest::<T>::get(idty) == Some(caller.clone()),
+            "Request not added"
+        );
+        assert_has_event::<T>(
+            Event::<T>::EvaluationRequested {
+                idty_index: idty,
+                who: caller,
+            }
+            .into(),
+        );
     }
 
-    // request distance evaluation for
-    request_distance_evaluation_for {
+    #[benchmark]
+    fn request_distance_evaluation_for() {
         let idty = T::IdtyIndex::one();
-        let caller: T::AccountId  = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-        let _ = <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
-        let target = 2u32;
+        let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty)
+            .unwrap()
+            .owner_key;
+        <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
+        let target: T::IdtyIndex = 2u32;
         // set target status since targeted distance evaluation only allowed for unvalidated
-        pallet_identity::Identities::<T>::mutate(target,
-            |idty_val| idty_val.as_mut().unwrap().status = pallet_identity::IdtyStatus::Unvalidated);
-    }: _<T::RuntimeOrigin>(caller_origin.clone(), target)
-    verify {
-        assert!(PendingEvaluationRequest::<T>::get(target) == Some(caller.clone()), "Request not added");
-        assert_has_event::<T>(Event::<T>::EvaluationRequested { idty_index: target, who: caller }.into());
+        pallet_identity::Identities::<T>::mutate(target, |idty_val| {
+            idty_val.as_mut().unwrap().status = pallet_identity::IdtyStatus::Unvalidated
+        });
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller.clone()), target);
+
+        assert!(
+            PendingEvaluationRequest::<T>::get(target) == Some(caller.clone()),
+            "Request not added"
+        );
+        assert_has_event::<T>(
+            Event::<T>::EvaluationRequested {
+                idty_index: target,
+                who: caller,
+            }
+            .into(),
+        );
     }
 
-    // update evaluation
-    update_evaluation {
+    #[benchmark]
+    fn update_evaluation(i: Linear<1, MAX_EVALUATIONS_PER_SESSION>) -> Result<(), BenchmarkError> {
         let digest_data = sp_consensus_babe::digests::PreDigest::SecondaryPlain(
-        sp_consensus_babe::digests::SecondaryPlainPreDigest { authority_index: 0u32, slot: Default::default() });
+            sp_consensus_babe::digests::SecondaryPlainPreDigest {
+                authority_index: 0u32,
+                slot: Default::default(),
+            },
+        );
         // A BABE digest item is needed to check authorship
         let digest = sp_runtime::DigestItem::PreRuntime(*b"BABE", digest_data.encode());
-        let _ = <frame_system::Pallet<T>>::deposit_log(digest);
-        let idty = T::IdtyIndex::one();
-        let caller: T::AccountId  = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-        let i in 1 .. MAX_EVALUATIONS_PER_SESSION => populate_pool::<T>(i)?;
-    }: _<T::RuntimeOrigin>(RawOrigin::None.into(), ComputationResult{distances: vec![Perbill::one(); i as usize]})
+        <frame_system::Pallet<T>>::deposit_log(digest);
+        populate_pool::<T>(i)?;
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::None,
+            ComputationResult {
+                distances: vec![Perbill::one(); i as usize],
+            },
+        );
 
-    // force update evaluation
-    force_update_evaluation {
+        Ok(())
+    }
+
+    #[benchmark]
+    fn force_update_evaluation(
+        i: Linear<1, MAX_EVALUATIONS_PER_SESSION>,
+    ) -> Result<(), BenchmarkError> {
         let idty = T::IdtyIndex::one();
-            let caller: T::AccountId  = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
-            let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-            let i in 1 .. MAX_EVALUATIONS_PER_SESSION => populate_pool::<T>(i)?;
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), caller.clone(), ComputationResult{distances: vec![Perbill::one(); i as usize]})
+        let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty)
+            .unwrap()
+            .owner_key;
+        populate_pool::<T>(i)?;
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Root,
+            caller,
+            ComputationResult {
+                distances: vec![Perbill::one(); i as usize],
+            },
+        );
+
+        Ok(())
+    }
 
-    // force valid distance status
-    force_valid_distance_status {
+    #[benchmark]
+    fn force_valid_distance_status() {
         let idty = T::IdtyIndex::one();
-        let caller: T::AccountId  = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), idty)
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, idty);
+
         assert_has_event::<T>(Event::<T>::EvaluatedValid { idty_index: idty }.into());
     }
 
-    // on finalize
-    on_finalize {
+    #[benchmark]
+    fn on_finalize() {
         DidUpdate::<T>::set(true);
-    }: { Pallet::<T>::on_finalize(Default::default()); }
-    verify {
+
+        #[block]
+        {
+            Pallet::<T>::on_finalize(Default::default());
+        }
+
         assert!(!DidUpdate::<T>::get());
     }
 

pallets/duniter-account/src/benchmarking.rs

@@ -18,13 +18,18 @@
 
 use super::*;
 
-use frame_benchmarking::{account, benchmarks, whitelisted_caller};
+use frame_benchmarking::v2::*;
 use frame_support::sp_runtime::{traits::One, Saturating};
-use frame_support::traits::{Currency, Get};
+use frame_support::traits::Currency;
+use frame_system::RawOrigin;
 use pallet_provide_randomness::OnFilledRandomness;
 
 use crate::Pallet;
 
+#[benchmarks]
+mod benchmarks {
+    use super::*;
+
     fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
         frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
@@ -39,7 +44,8 @@ fn create_pending_accounts<T: Config>(
             if is_balance {
                 let existential_deposit = T::ExistentialDeposit::get();
                 let balance = existential_deposit.saturating_mul((200u32).into());
-            let _ = <pallet_balances::Pallet<T> as Currency<T::AccountId>>::make_free_balance_be(
+                let _ =
+                    <pallet_balances::Pallet<T> as Currency<T::AccountId>>::make_free_balance_be(
                         &caller, balance,
                     );
             } else {
@@ -58,33 +64,93 @@ fn create_pending_accounts<T: Config>(
         Ok(())
     }
 
-benchmarks! {
-    unlink_identity {
+    #[benchmark]
+    fn unlink_identity() {
         let account = account("Alice", 1, 1);
-        let origin = frame_system::RawOrigin::Signed(account);
-    }: _<T::RuntimeOrigin>(origin.into())
-    on_initialize_sufficient  {
-        let i in 0 .. T::MaxNewAccountsPerBlock::get() => create_pending_accounts::<T>(i, false, true)?;
-    }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
-    on_initialize_with_balance {
-        let i in 0 .. T::MaxNewAccountsPerBlock::get() => create_pending_accounts::<T>(i, true, false)?;
-    }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
-    on_initialize_no_balance {
-        let i in 0 .. T::MaxNewAccountsPerBlock::get() => create_pending_accounts::<T>(i, false, false)?;
-    }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
-    on_filled_randomness_pending {
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(account));
+    }
+
+    #[benchmark]
+    fn on_initialize_sufficient(
+        i: Linear<0, { T::MaxNewAccountsPerBlock::get() }>,
+    ) -> Result<(), BenchmarkError> {
+        create_pending_accounts::<T>(i, false, true)?;
+
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
+        }
+
+        Ok(())
+    }
+
+    #[benchmark]
+    fn on_initialize_with_balance(
+        i: Linear<0, { T::MaxNewAccountsPerBlock::get() }>,
+    ) -> Result<(), BenchmarkError> {
+        create_pending_accounts::<T>(i, true, false)?;
+
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
+        }
+
+        Ok(())
+    }
+
+    #[benchmark]
+    fn on_initialize_no_balance(
+        i: Linear<0, { T::MaxNewAccountsPerBlock::get() }>,
+    ) -> Result<(), BenchmarkError> {
+        create_pending_accounts::<T>(i, false, false)?;
+
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
+        }
+
+        Ok(())
+    }
+
+    #[benchmark]
+    fn on_filled_randomness_pending() {
         let caller: T::AccountId = whitelisted_caller();
         let randomness = H256(T::AccountIdToSalt::convert(caller.clone()));
-        let request_id = pallet_provide_randomness::Pallet::<T>::force_request(pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo, randomness);
+        let request_id = pallet_provide_randomness::Pallet::<T>::force_request(
+            pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo,
+            randomness,
+        );
         PendingRandomIdAssignments::<T>::insert(request_id, caller.clone());
-    }: { Pallet::<T>::on_filled_randomness(request_id,  randomness); }
-    verify {
-        assert_has_event::<T>(Event::<T>::RandomIdAssigned { who: caller, random_id: randomness }.into());
+
+        #[block]
+        {
+            Pallet::<T>::on_filled_randomness(request_id, randomness);
         }
-    on_filled_randomness_no_pending {
+
+        assert_has_event::<T>(
+            Event::<T>::RandomIdAssigned {
+                who: caller,
+                random_id: randomness,
+            }
+            .into(),
+        );
+    }
+
+    #[benchmark]
+    fn on_filled_randomness_no_pending() {
         let caller: T::AccountId = whitelisted_caller();
         let randomness = H256(T::AccountIdToSalt::convert(caller.clone()));
-        let request_id = pallet_provide_randomness::Pallet::<T>::force_request(pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo, randomness);
+        let request_id = pallet_provide_randomness::Pallet::<T>::force_request(
+            pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo,
+            randomness,
+        );
         assert!(!PendingRandomIdAssignments::<T>::contains_key(request_id));
-    }: { Pallet::<T>::on_filled_randomness(request_id,  randomness); }
+
+        #[block]
+        {
+            Pallet::<T>::on_filled_randomness(request_id, randomness);
+        }
+    }
 }

pallets/identity/src/benchmarking.rs

@@ -20,7 +20,8 @@ use super::*;
 
 //use codec::Encode;
 use codec::Encode;
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::account;
+use frame_benchmarking::v2::*;
 use frame_support::traits::OnInitialize;
 use frame_system::pallet_prelude::BlockNumberFor;
 use frame_system::RawOrigin;
@@ -30,7 +31,15 @@ use sp_runtime::{AccountId32, MultiSigner};
 
 use crate::Pallet;
 
-const SEED: u32 = 1;
+#[benchmarks(
+        where
+            T::Signature: From<sp_core::sr25519::Signature>,
+            T::Signature: From<sp_core::sr25519::Signature>,
+            T::AccountId: From<AccountId32>,
+            T::IdtyIndex: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
 
     fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
         frame_system::Pallet::<T>::assert_has_event(generic_event.into());
@@ -40,7 +49,6 @@ struct Account<T: Config> {
         key: T::AccountId,
         index: T::IdtyIndex,
         origin: <T as frame_system::Config>::RuntimeOrigin,
-    // name: IdtyName,
     }
 
     // Create and confirm one account using Alice authorized account.
@@ -83,7 +91,7 @@ fn create_one_identity<T: Config>(owner_key: T::AccountId) -> Result<Account<T>,
     // Create a dummy identity bypassing all the checks.
     fn create_dummy_identity<T: Config>(i: u32) -> Result<(), &'static str> {
         let idty_index: T::IdtyIndex = i.into();
-    let owner_key: T::AccountId = account("Bob", i, SEED);
+        let owner_key: T::AccountId = account("Bob", i, 1);
         let next_scheduled = BlockNumberFor::<T>::zero();
         let value = IdtyValue {
             data: Default::default(),
@@ -115,43 +123,54 @@ fn create_identities<T: Config>(i: u32) -> Result<(), &'static str> {
         Ok(())
     }
 
-benchmarks! {
-    where_clause {
-        where
-            T::Signature: From<sp_core::sr25519::Signature>,
-            T::Signature: From<sp_core::sr25519::Signature>,
-            T::AccountId: From<AccountId32>,
-            T::IdtyIndex: From<u32>,
-    }
-
-    // create identity
-    create_identity {
+    #[benchmark]
+    fn create_identity() {
         let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key; // Alice
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-        let owner_key: T::AccountId = account("new_identity", 2, SEED);
-    }: _<T::RuntimeOrigin>(caller_origin.clone(), owner_key.clone())
-    verify {
+        let owner_key: T::AccountId = account("new_identity", 2, 1);
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), owner_key.clone());
+
         let idty_index = IdentityIndexOf::<T>::get(&owner_key);
         assert!(idty_index.is_some(), "Identity not added");
-        assert_has_event::<T>(Event::<T>::IdtyCreated { idty_index: idty_index.unwrap(), owner_key }.into());
+        assert_has_event::<T>(
+            Event::<T>::IdtyCreated {
+                idty_index: idty_index.unwrap(),
+                owner_key,
+            }
+            .into(),
+        );
     }
 
-    // confirm identity
-    confirm_identity {
+    #[benchmark]
+    fn confirm_identity() -> Result<(), BenchmarkError> {
         let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-        let owner_key: T::AccountId = account("new_identity", 2, SEED);
-        let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(owner_key.clone()).into();
+        let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
+            RawOrigin::Signed(caller.clone()).into();
+        let owner_key: T::AccountId = account("new_identity", 2, 1);
         Pallet::<T>::create_identity(caller_origin.clone(), owner_key.clone())?;
-    }: _<T::RuntimeOrigin>(owner_key_origin.clone(), IdtyName("new_identity".into()))
-    verify {
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Signed(owner_key.clone()),
+            IdtyName("new_identity".into()),
+        );
+
         let idty_index = IdentityIndexOf::<T>::get(&owner_key);
-        assert_has_event::<T>(Event::<T>::IdtyConfirmed { idty_index: idty_index.unwrap(), owner_key, name: IdtyName("new_identity".into()) }.into());
+        assert_has_event::<T>(
+            Event::<T>::IdtyConfirmed {
+                idty_index: idty_index.unwrap(),
+                owner_key,
+                name: IdtyName("new_identity".into()),
+            }
+            .into(),
+        );
+        Ok(())
     }
 
-    // change owner key
-    change_owner_key {
-        let old_key: T::AccountId = account("new_identity", 2, SEED);
+    #[benchmark]
+    fn change_owner_key() -> Result<(), BenchmarkError> {
+        let old_key: T::AccountId = account("new_identity", 2, 1);
         let account: Account<T> = create_one_identity(old_key.clone())?;
 
         // Change key a first time to add an old-old key
@@ -164,12 +183,14 @@ benchmarks! {
         let message = (NEW_OWNER_KEY_PAYLOAD_PREFIX, new_key_payload).encode();
         let caller_public = sr25519_generate(0.into(), None);
         let caller: T::AccountId = MultiSigner::Sr25519(caller_public).into_account().into();
-        let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
+        let signature = sr25519_sign(0.into(), &caller_public, &message)
+            .unwrap()
+            .into();
         Pallet::<T>::change_owner_key(account.origin.clone(), caller.clone(), signature)?;
 
         // Change key a second time to benchmark
         //  The sufficients for the old_old key will drop to 0 during benchmark
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+        let caller_origin = RawOrigin::Signed(caller.clone());
         let genesis_hash = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
         let new_key_payload = IdtyIndexAccountIdPayload {
             genesis_hash: &genesis_hash,
@@ -179,17 +200,33 @@ benchmarks! {
         let message = (NEW_OWNER_KEY_PAYLOAD_PREFIX, new_key_payload).encode();
         let caller_public = sr25519_generate(0.into(), None);
         let caller: T::AccountId = MultiSigner::Sr25519(caller_public).into_account().into();
-        let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
-        <frame_system::Pallet<T>>::set_block_number(<frame_system::Pallet<T>>::block_number() + T::ChangeOwnerKeyPeriod::get());
-    }: _<T::RuntimeOrigin>(caller_origin.clone(), caller.clone(), signature)
-    verify {
-        assert_has_event::<T>(Event::<T>::IdtyChangedOwnerKey { idty_index: account.index, new_owner_key: caller.clone() }.into());
-        assert!(IdentityIndexOf::<T>::get(&caller).unwrap() == account.index, "Owner key not changed");
+        let signature = sr25519_sign(0.into(), &caller_public, &message)
+            .unwrap()
+            .into();
+        <frame_system::Pallet<T>>::set_block_number(
+            <frame_system::Pallet<T>>::block_number() + T::ChangeOwnerKeyPeriod::get(),
+        );
+
+        #[extrinsic_call]
+        _(caller_origin, caller.clone(), signature);
+
+        assert_has_event::<T>(
+            Event::<T>::IdtyChangedOwnerKey {
+                idty_index: account.index,
+                new_owner_key: caller.clone(),
+            }
+            .into(),
+        );
+        assert!(
+            IdentityIndexOf::<T>::get(&caller).unwrap() == account.index,
+            "Owner key not changed"
+        );
+        Ok(())
     }
 
-    // revoke identity
-    revoke_identity {
-        let old_key: T::AccountId = account("new_identity", 2, SEED);
+    #[benchmark]
+    fn revoke_identity() -> Result<(), BenchmarkError> {
+        let old_key: T::AccountId = account("new_identity", 2, 1);
         let account: Account<T> = create_one_identity(old_key.clone())?;
 
         // Change key
@@ -203,7 +240,9 @@ benchmarks! {
         let message = (NEW_OWNER_KEY_PAYLOAD_PREFIX, new_key_payload).encode();
         let caller_public = sr25519_generate(0.into(), None);
         let caller: T::AccountId = MultiSigner::Sr25519(caller_public).into_account().into();
-        let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
+        let signature = sr25519_sign(0.into(), &caller_public, &message)
+            .unwrap()
+            .into();
         Pallet::<T>::change_owner_key(account.origin.clone(), caller.clone(), signature)?;
 
         let genesis_hash = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
@@ -212,147 +251,252 @@ benchmarks! {
             idty_index: account.index,
         };
         let message = (REVOCATION_PAYLOAD_PREFIX, revocation_payload).encode();
-        let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
-    }: _<T::RuntimeOrigin>(account.origin, account.index, caller.clone(), signature)
-    verify {
-        assert_has_event::<T>(Event::<T>::IdtyRevoked { idty_index: account.index, reason: RevocationReason::User }.into());
-        // revocation does not mean deletion anymore
-        // assert!(IdentityIndexOf::<T>::get(&account.key).is_none(), "Identity not revoked");
+        let signature = sr25519_sign(0.into(), &caller_public, &message)
+            .unwrap()
+            .into();
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Signed(account.key),
+            account.index,
+            caller.clone(),
+            signature,
+        );
+
+        assert_has_event::<T>(
+            Event::<T>::IdtyRevoked {
+                idty_index: account.index,
+                reason: RevocationReason::User,
+            }
+            .into(),
+        );
+        Ok(())
     }
 
+    #[benchmark]
+    fn prune_item_identities_names(i: Linear<2, 1_000>) -> Result<(), BenchmarkError> {
         // The complexity depends on the number of identities to prune
-    prune_item_identities_names {
         // Populate identities
         let identities_count = Pallet::<T>::identities_count();
-        let i in 1 .. 1000 => create_identities::<T>(i)?;
+        create_identities::<T>(i)?;
 
         let mut names = Vec::<IdtyName>::new();
         for k in 1..i {
             let name: IdtyName = IdtyName((k + identities_count).to_le_bytes().into());
-            assert!(IdentitiesNames::<T>::contains_key(&name), "Name not existing");
+            assert!(
+                IdentitiesNames::<T>::contains_key(&name),
+                "Name not existing"
+            );
             names.push(name);
         }
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), names.clone())
-    verify {
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, names.clone());
+
         for name in names {
             assert!(!IdentitiesNames::<T>::contains_key(&name), "Name existing");
         }
+        Ok(())
     }
 
-    // fix sufficients identity
-    fix_sufficients {
-        let new_identity: T::AccountId = account("Bob", 2, SEED);
+    #[benchmark]
+    fn fix_sufficients() -> Result<(), BenchmarkError> {
+        let new_identity: T::AccountId = account("Bob", 2, 1);
         let account: Account<T> = create_one_identity(new_identity)?;
         let sufficient = frame_system::Pallet::<T>::sufficients(&account.key);
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), account.key.clone(), true)
-    verify {
-        assert!(sufficient < frame_system::Pallet::<T>::sufficients(&account.key), "Sufficient not incremented");
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, account.key.clone(), true);
+
+        assert!(
+            sufficient < frame_system::Pallet::<T>::sufficients(&account.key),
+            "Sufficient not incremented"
+        );
+        Ok(())
     }
 
-    // link account
-    link_account {
-        let alice_origin = RawOrigin::Signed(Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key);
+    #[benchmark]
+    fn link_account() -> Result<(), BenchmarkError> {
+        let alice_origin =
+            RawOrigin::Signed(Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key);
         let bob_public = sr25519_generate(0.into(), None);
         let bob: T::AccountId = MultiSigner::Sr25519(bob_public).into_account().into();
         frame_system::Pallet::<T>::inc_providers(&bob);
         let genesis_hash = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
         let payload = (
-            LINK_IDTY_PAYLOAD_PREFIX, genesis_hash, T::IdtyIndex::one(), bob.clone(),
-        ).encode();
-        let signature = sr25519_sign(0.into(), &bob_public, &payload).unwrap().into();
-    }: _<T::RuntimeOrigin>(alice_origin.into(), bob, signature)
+            LINK_IDTY_PAYLOAD_PREFIX,
+            genesis_hash,
+            T::IdtyIndex::one(),
+            bob.clone(),
+        )
+            .encode();
+        let signature = sr25519_sign(0.into(), &bob_public, &payload)
+            .unwrap()
+            .into();
 
+        #[extrinsic_call]
+        _(alice_origin, bob, signature);
+
+        Ok(())
+    }
+
+    #[benchmark]
+    fn on_initialize() {
         // Base weight of an empty initialize
-    on_initialize {
-    }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
+        }
+    }
 
-    // --- do revoke identity
-    do_revoke_identity_noop {
+    #[benchmark]
+    fn do_revoke_identity_noop() {
         let idty_index: T::IdtyIndex = 0u32.into();
         assert!(Identities::<T>::get(idty_index).is_none());
-    }: {Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);}
-    do_revoke_identity {
+
+        #[block]
+        {
+            Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);
+        }
+    }
+
+    #[benchmark]
+    fn do_revoke_identity() {
         let idty_index: T::IdtyIndex = 1u32.into();
-        let new_identity: T::AccountId = account("Bob", 2, SEED);
+        let new_identity: T::AccountId = account("Bob", 2, 1);
         assert!(Identities::<T>::get(idty_index).is_some());
         Identities::<T>::mutate(idty_index, |id| {
             if let Some(id) = id {
                 id.old_owner_key = Some((new_identity, BlockNumberFor::<T>::zero()));
             }
         });
-        assert!(Identities::<T>::get(idty_index).unwrap().old_owner_key.is_some());
-    }: {Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);}
-    verify {
-        assert_has_event::<T>(Event::<T>::IdtyRevoked { idty_index, reason: RevocationReason::Root }.into());
+        assert!(Identities::<T>::get(idty_index)
+            .unwrap()
+            .old_owner_key
+            .is_some());
+
+        #[block]
+        {
+            Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);
+        }
+
+        assert_has_event::<T>(
+            Event::<T>::IdtyRevoked {
+                idty_index,
+                reason: RevocationReason::Root,
+            }
+            .into(),
+        );
     }
 
-    // --- do remove identity
-    do_remove_identity_noop {
+    #[benchmark]
+    fn do_remove_identity_noop() {
         let idty_index: T::IdtyIndex = 0u32.into();
         assert!(Identities::<T>::get(idty_index).is_none());
-    }: {Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);}
-    do_remove_identity {
+
+        #[block]
+        {
+            Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);
+        }
+    }
+
+    #[benchmark]
+    fn do_remove_identity() {
         let idty_index: T::IdtyIndex = 1u32.into();
-        let new_identity: T::AccountId = account("Bob", 2, SEED);
+        let new_identity: T::AccountId = account("Bob", 2, 1);
         assert!(Identities::<T>::get(idty_index).is_some());
         Identities::<T>::mutate(idty_index, |id| {
             if let Some(id) = id {
                 id.old_owner_key = Some((new_identity, BlockNumberFor::<T>::zero()));
             }
         });
-        assert!(Identities::<T>::get(idty_index).unwrap().old_owner_key.is_some());
-    }: {Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);}
-    verify {
-        assert_has_event::<T>(Event::<T>::IdtyRemoved { idty_index, reason: RemovalReason::Revoked }.into());
+        assert!(Identities::<T>::get(idty_index)
+            .unwrap()
+            .old_owner_key
+            .is_some());
+
+        #[block]
+        {
+            Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);
+        }
+
+        assert_has_event::<T>(
+            Event::<T>::IdtyRemoved {
+                idty_index,
+                reason: RemovalReason::Revoked,
+            }
+            .into(),
+        );
     }
 
-    // --- prune identities
-    prune_identities_noop {
+    #[benchmark]
+    fn prune_identities_noop() {
         assert!(IdentityChangeSchedule::<T>::try_get(BlockNumberFor::<T>::zero()).is_err());
-    }: {Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());}
 
-    prune_identities_none {
+        #[block]
+        {
+            Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());
+        }
+    }
+
+    #[benchmark]
+    fn prune_identities_none() {
         let idty_index: T::IdtyIndex = 100u32.into();
         IdentityChangeSchedule::<T>::append(BlockNumberFor::<T>::zero(), idty_index);
         assert!(IdentityChangeSchedule::<T>::try_get(BlockNumberFor::<T>::zero()).is_ok());
         assert!(<Identities<T>>::try_get(idty_index).is_err());
-    }: {Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());}
 
-    prune_identities_err {
+        #[block]
+        {
+            Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());
+        }
+    }
+
+    #[benchmark]
+    fn prune_identities_err() -> Result<(), BenchmarkError> {
         let idty_index: T::IdtyIndex = 100u32.into();
         create_dummy_identity::<T>(100u32)?;
         IdentityChangeSchedule::<T>::append(BlockNumberFor::<T>::zero(), idty_index);
-    }: {Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());}
+
+        #[block]
+        {
+            Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());
+        }
+
+        Ok(())
+    }
 
     impl_benchmark_test_suite!(
         Pallet,
         // Create genesis identity Alice to test benchmark in mock
-        crate::mock::new_test_ext(crate::mock::IdentityConfig{ identities: vec![
-            GenesisIdty {
+        crate::mock::new_test_ext(crate::mock::IdentityConfig {
+            identities: vec![
+                crate::GenesisIdty {
                     index: 1,
-                name: IdtyName::from("Alice"),
-                value: IdtyValue {
+                    name: crate::IdtyName::from("Alice"),
+                    value: crate::IdtyValue {
                         data: (),
                         next_creatable_identity_on: 0,
                         old_owner_key: None,
-                    owner_key: account("Alice", 1, SEED),
+                        owner_key: frame_benchmarking::account("Alice", 1, 1),
                         next_scheduled: 0,
                         status: crate::IdtyStatus::Member,
                     },
                 },
-            GenesisIdty {
+                crate::GenesisIdty {
                     index: 2,
-                name: IdtyName::from("Bob"),
-                value: IdtyValue {
+                    name: crate::IdtyName::from("Bob"),
+                    value: crate::IdtyValue {
                         data: (),
                         next_creatable_identity_on: 0,
                         old_owner_key: None,
-                    owner_key: account("Bob", 1, SEED),
+                        owner_key: frame_benchmarking::account("Bob", 1, 1),
                         next_scheduled: 0,
                         status: crate::IdtyStatus::Unconfirmed,
                     },
                 },
-        ]}),
+            ]
+        }),
         crate::mock::Test,
     );
 }

pallets/membership/src/benchmarking.rs

@@ -18,36 +18,36 @@
 
 use super::*;
 
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_system::pallet_prelude::BlockNumberFor;
 
-#[cfg(test)]
-use maplit::btreemap;
-
 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_clause {
+#[benchmarks(
         where
             T::IdtyId: From<u32>,
             BlockNumberFor<T>: From<u32>,
-    }
+)]
+mod benchmarks {
+    use super::*;
 
     // TODO membership add and renewal should be included to distance on_new_session as worst case scenario
 
+    #[benchmark]
+    fn on_initialize() {
         // Base weight of an empty initialize
-    on_initialize {
-    }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
+        }
+    }
 
-    expire_memberships {
-        let i in 0..3; // Limited by the number of validators
+    #[benchmark]
+    fn expire_memberships(i: Linear<0, 3>) {
+        // Limited by the number of validators
         // Arbitrarily high, to be in the worst case of wot instance,
         // this will overcount the weight in hooks see https://git.duniter.org/nodes/rust/duniter-v2s/-/issues/167
-        let block_number: BlockNumberFor::<T> = 10_000_000.into();
+        let block_number: BlockNumberFor<T> = 10_000_000.into();
         frame_system::pallet::Pallet::<T>::set_block_number(block_number);
         let mut idties: Vec<T::IdtyId> = Vec::new();
         for j in 1..i + 1 {
@@ -56,20 +56,28 @@ benchmarks! {
             idties.push(j);
         }
         MembershipsExpireOn::<T>::insert(block_number, idties);
-        assert_eq!(MembershipsExpireOn::<T>::get(block_number).len(), i as usize);
-    }: {Pallet::<T>::expire_memberships(block_number);}
-    verify {
+        assert_eq!(
+            MembershipsExpireOn::<T>::get(block_number).len(),
+            i as usize
+        );
+
+        #[block]
+        {
+            Pallet::<T>::expire_memberships(block_number);
+        }
+
         assert_eq!(MembershipsExpireOn::<T>::get(block_number).len(), 0_usize);
     }
 
     impl_benchmark_test_suite!(
         Pallet,
         crate::mock::new_test_ext(crate::mock::MembershipConfig {
-        memberships: btreemap![
-            3 => MembershipData {
+            memberships: maplit::btreemap![
+                3 => crate::MembershipData {
                     expire_on: 3,
                 },
-        ],}),
+            ],
+        }),
         crate::mock::Test
     );
 }

pallets/oneshot-account/src/benchmarking.rs

@@ -18,7 +18,8 @@
 
 use super::*;
 
-use frame_benchmarking::{account, benchmarks, whitelisted_caller};
+use frame_benchmarking::v2::*;
+use frame_benchmarking::{account, whitelisted_caller};
 use frame_support::pallet_prelude::IsType;
 use frame_support::traits::Get;
 use frame_system::RawOrigin;
@@ -26,90 +27,99 @@ use pallet_balances::Pallet as Balances;
 
 use crate::Pallet;
 
-const SEED: u32 = 0;
-
-benchmarks! {
-    where_clause {
+#[benchmarks(
         where
         T: pallet_balances::Config,
         T::Balance: From<u64>,
         <T::Currency as Currency<T::AccountId>>::Balance: IsType<T::Balance>+From<T::Balance>
-    }
-    create_oneshot_account {
+)]
+mod benchmarks {
+    use super::*;
+
+    #[benchmark]
+    fn create_oneshot_account() {
         let existential_deposit = T::ExistentialDeposit::get();
         let caller = whitelisted_caller();
-
-        // Give some multiple of the existential deposit
         let balance = existential_deposit.saturating_mul((2).into());
         let _ = T::Currency::make_free_balance_be(&caller, balance.into());
-
-        let recipient: T::AccountId = account("recipient", 0, SEED);
+        let recipient: T::AccountId = account("recipient", 0, 1);
         let recipient_lookup: <T::Lookup as StaticLookup>::Source =
             T::Lookup::unlookup(recipient.clone());
         let transfer_amount = existential_deposit;
-    }: _(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount.into())
-    verify {
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Signed(caller.clone()),
+            recipient_lookup,
+            transfer_amount.into(),
+        );
+
         assert_eq!(Balances::<T>::free_balance(&caller), transfer_amount);
-        assert_eq!(OneshotAccounts::<T>::get(&recipient), Some(transfer_amount.into()));
+        assert_eq!(
+            OneshotAccounts::<T>::get(&recipient),
+            Some(transfer_amount.into())
+        );
     }
-    consume_oneshot_account {
+
+    #[benchmark]
+    fn consume_oneshot_account() {
         let existential_deposit = T::ExistentialDeposit::get();
         let caller: T::AccountId = whitelisted_caller();
-
-        // Give some multiple of the existential deposit
         let balance = existential_deposit.saturating_mul((2).into());
         OneshotAccounts::<T>::insert(
             caller.clone(),
-            Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance)
+            Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance),
         );
-
         // Deposit into a normal account is more expensive than into a oneshot account
         // so we create the recipient account with an existential deposit.
-        let recipient: T::AccountId = account("recipient", 0, SEED);
+        let recipient: T::AccountId = account("recipient", 0, 1);
         let recipient_lookup: <T::Lookup as StaticLookup>::Source =
             T::Lookup::unlookup(recipient.clone());
         let _ = T::Currency::make_free_balance_be(&recipient, existential_deposit.into());
-    }: _(
+
+        #[extrinsic_call]
+        _(
             RawOrigin::Signed(caller.clone()),
             BlockNumberFor::<T>::zero(),
-        Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient_lookup)
-    )
-    verify {
+            Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient_lookup),
+        );
+
         assert_eq!(OneshotAccounts::<T>::get(&caller), None);
         assert_eq!(
             Balances::<T>::free_balance(&recipient),
             existential_deposit.saturating_mul((3).into())
         );
     }
-    consume_oneshot_account_with_remaining {
+
+    #[benchmark]
+    fn consume_oneshot_account_with_remaining() {
         let existential_deposit = T::ExistentialDeposit::get();
         let caller: T::AccountId = whitelisted_caller();
-
-        // Give some multiple of the existential deposit
         let balance = existential_deposit.saturating_mul((2).into());
         OneshotAccounts::<T>::insert(
             caller.clone(),
-            Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance)
+            Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance),
         );
-
         // Deposit into a normal account is more expensive than into a oneshot account
         // so we create the recipient accounts with an existential deposits.
-        let recipient1: T::AccountId = account("recipient1", 0, SEED);
+        let recipient1: T::AccountId = account("recipient1", 0, 1);
         let recipient1_lookup: <T::Lookup as StaticLookup>::Source =
             T::Lookup::unlookup(recipient1.clone());
         let _ = T::Currency::make_free_balance_be(&recipient1, existential_deposit.into());
-        let recipient2: T::AccountId = account("recipient2", 1, SEED);
+        let recipient2: T::AccountId = account("recipient2", 1, 1);
         let recipient2_lookup: <T::Lookup as StaticLookup>::Source =
             T::Lookup::unlookup(recipient2.clone());
         let _ = T::Currency::make_free_balance_be(&recipient2, existential_deposit.into());
-    }: _(
+
+        #[extrinsic_call]
+        _(
             RawOrigin::Signed(caller.clone()),
             BlockNumberFor::<T>::zero(),
             Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient1_lookup),
             Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient2_lookup),
-        existential_deposit.into()
-    )
-    verify {
+            existential_deposit.into(),
+        );
+
         assert_eq!(OneshotAccounts::<T>::get(&caller), None);
         assert_eq!(
             Balances::<T>::free_balance(&recipient1),
@@ -121,9 +131,5 @@ benchmarks! {
         );
     }
 
-    impl_benchmark_test_suite!(
-        Pallet,
-        crate::mock::new_test_ext(),
-        crate::mock::Test
-    );
+    impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
 }