update to benchmarking v2

pallets/authority-members/src/benchmarking.rs

@@ -17,70 +17,83 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-
-use frame_benchmarking::benchmarks;
-use frame_system::RawOrigin;
-
 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());
-}
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
 
-benchmarks! {
-    where_clause {
+#[benchmarks(
         where
-            T::MemberId: From<u32>,
+            <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());
     }
-    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 {
-        assert_has_event::<T>(Event::<T>::MemberGoOffline{member: id}.into());
+
+        #[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 {
-        assert_has_event::<T>(Event::<T>::MemberGoOnline{member: id}.into());
+
+        #[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 {
+        let validator_id = T::ValidatorIdOf::convert(caller.clone()).unwrap();
+        let session_keys: T::Keys = pallet_session::NextKeys::<T>::get(validator_id).unwrap();
+
+        #[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 {
-        assert_has_event::<T>(Event::<T>::MemberRemoved{member: id}.into());
+
+        #[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 {
-        assert_has_event::<T>(Event::<T>::MemberRemovedFromBlacklist{member: id}.into());
+
+        #[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,122 +18,160 @@
 
 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;
 
-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 as Config>::IdtyIndex: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
 
-fn add_certs<T: Config>(i: u32, receiver: T::IdtyIndex) -> Result<(), &'static str> {
-    Pallet::<T>::remove_all_certs_received_by(RawOrigin::Root.into(), receiver)?;
-    for j in 1..i {
-        Pallet::<T>::do_add_cert_checked(j.into(), receiver, false)?;
+    fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+        frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
-    assert!(
-        CertsByReceiver::<T>::get(receiver).len() as u32 == i - 1,
-        "Certs not added",
-    );
-    Ok(())
-}
 
-benchmarks! {
-    where_clause {
-        where
-            T::IdtyIndex: From<u32>,
+    fn add_certs<T: Config>(i: u32, receiver: T::IdtyIndex) -> Result<(), &'static str> {
+        Pallet::<T>::remove_all_certs_received_by(RawOrigin::Root.into(), receiver)?;
+        for j in 1..i {
+            Pallet::<T>::do_add_cert_checked(j.into(), receiver, false)?;
+        }
+        assert!(
+            CertsByReceiver::<T>::get(receiver).len() as u32 == i - 1,
+            "Certs not added",
+        );
+        Ok(())
     }
-    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 caller: T::AccountId = T::IdtyAttr::owner_key(issuer).unwrap();
         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 {
-        assert_has_event::<T>(Event::<T>::CertAdded{ issuer, receiver }.into());
+
+        #[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 caller: T::AccountId = T::IdtyAttr::owner_key(issuer).unwrap();
         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 {
-        assert_has_event::<T>(Event::<T>::CertAdded{ issuer, receiver }.into());
+        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 {
-        assert!(CertsByReceiver::<T>::get(receiver).is_empty() );
+        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![
+            apply_cert_period_at_genesis: true,
+            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),
                 ],
-            ] ,
+            ],
         }),
         crate::mock::Test
     );

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,92 +29,150 @@ use sp_runtime::Perbill;
 
 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());
-}
-
-fn populate_pool<T: Config>(i: u32) -> Result<(), &'static str> {
-    EvaluationPool0::<T>::mutate(|current_pool| -> Result<(), &'static str> {
-        for j in 0..i {
-            current_pool
-                .evaluations
-                .try_push((j, median::MedianAcc::new()))
-                .map_err(|_| Error::<T>::QueueFull)?;
-        }
-        Ok(())
-    })
-}
-
-benchmarks! {
-    where_clause {
+#[benchmarks(
         where
-        T: pallet_balances::Config, T::Balance: From<u64>,
+        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());
     }
 
-    // request distance evaluation
-    request_distance_evaluation {
+    fn populate_pool<T: Config>(i: u32) -> Result<(), &'static str> {
+        EvaluationPool0::<T>::mutate(|current_pool| -> Result<(), &'static str> {
+            for j in 0..i {
+                current_pool
+                    .evaluations
+                    .try_push((j, median::MedianAcc::new()))
+                    .map_err(|_| Error::<T>::QueueFull)?;
+            }
+            Ok(())
+        })
+    }
+
+    #[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);
+        <frame_system::Pallet<T>>::deposit_log(digest);
+        populate_pool::<T>(i)?;
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::None,
+            ComputationResult {
+                distances: vec![Perbill::one(); i as usize],
+            },
+        );
+
+        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::None.into(), ComputationResult{distances: vec![Perbill::one(); i as usize]})
-
-    // force update evaluation
-    force_update_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 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]})
-
-    // force valid distance status
-    force_valid_distance_status {
+        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(())
+    }
+
+    #[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,73 +18,139 @@
 
 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;
 
-fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
-    frame_system::Pallet::<T>::assert_has_event(generic_event.into());
-}
+#[benchmarks]
+mod benchmarks {
+    use super::*;
 
-fn create_pending_accounts<T: Config>(
-    i: u32,
-    is_balance: bool,
-    is_sufficient: bool,
-) -> Result<(), &'static str> {
-    for _ in 0..i {
-        let caller: T::AccountId = whitelisted_caller();
-        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(
-                &caller, balance,
-            );
-        } else {
-            assert!(
-                frame_system::Pallet::<T>::get(&caller).free
-                    < T::NewAccountPrice::get() + T::ExistentialDeposit::get()
-            );
-        }
-        if is_sufficient {
-            frame_system::Pallet::<T>::inc_sufficients(&caller);
-        } else {
-            assert!(frame_system::Pallet::<T>::sufficients(&caller) == 0);
+    fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+        frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+    }
+
+    fn create_pending_accounts<T: Config>(
+        i: u32,
+        is_balance: bool,
+        is_sufficient: bool,
+    ) -> Result<(), &'static str> {
+        for _ in 0..i {
+            let caller: T::AccountId = whitelisted_caller();
+            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(
+                        &caller, balance,
+                    );
+            } else {
+                assert!(
+                    frame_system::Pallet::<T>::get(&caller).free
+                        < T::NewAccountPrice::get() + T::ExistentialDeposit::get()
+                );
+            }
+            if is_sufficient {
+                frame_system::Pallet::<T>::inc_sufficients(&caller);
+            } else {
+                assert!(frame_system::Pallet::<T>::sufficients(&caller) == 0);
+            }
+            PendingNewAccounts::<T>::insert(caller, ());
         }
-        PendingNewAccounts::<T>::insert(caller, ());
+        Ok(())
     }
-    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);
+        }
+
+        assert_has_event::<T>(
+            Event::<T>::RandomIdAssigned {
+                who: caller,
+                random_id: randomness,
+            }
+            .into(),
+        );
     }
-    on_filled_randomness_no_pending {
+
+    #[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/membership/src/benchmarking.rs

@@ -18,58 +18,66 @@
 
 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
 
-    // Base weight of an empty initialize
-    on_initialize {
-    }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
+    #[benchmark]
+    fn on_initialize() {
+        // Base weight of an empty initialize
+        #[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 {
+        for j in 1..i + 1 {
             let j: T::IdtyId = j.into();
             Membership::<T>::insert(j, MembershipData::<BlockNumberFor<T>>::default());
             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 {
-                expire_on: 3,
-            },
-        ],}),
+            memberships: maplit::btreemap![
+                3 => crate::MembershipData {
+                    expire_on: 3,
+                },
+            ],
+        }),
         crate::mock::Test
     );
 }