diff --git a/pallets/authority-members/src/benchmarking.rs b/pallets/authority-members/src/benchmarking.rs
index 893d89ba867bb56f5d9f209536f2df6fccb428e4..808ea5865cee6ab763bcdf1be40adcc66ff08051 100644
--- a/pallets/authority-members/src/benchmarking.rs
+++ b/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);
}
diff --git a/pallets/certification/src/benchmarking.rs b/pallets/certification/src/benchmarking.rs
index 5aa67fdf40a170cd4d629e99ebdf6abbdb26c9d6..1f273af05a42c2cf90a87a1906e9ca8871cdb1bd 100644
--- a/pallets/certification/src/benchmarking.rs
+++ b/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
);
diff --git a/pallets/distance/src/benchmarking.rs b/pallets/distance/src/benchmarking.rs
index 4b5fb9557650cbae9ec1dc1f758c6de36d3852ec..0e888c8264c180d1ee4f494675ad8a853b4180b6 100644
--- a/pallets/distance/src/benchmarking.rs
+++ b/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());
}
diff --git a/pallets/duniter-account/src/benchmarking.rs b/pallets/duniter-account/src/benchmarking.rs
index 27a839e1a714503c4c3f01dd940f1cec48576771..74835636c1c00dd0fdc1f6757976e2cce2a43360 100644
--- a/pallets/duniter-account/src/benchmarking.rs
+++ b/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);
+ }
+ }
}
diff --git a/pallets/identity/src/benchmarking.rs b/pallets/identity/src/benchmarking.rs
index 0d4fe93e42ccc159f6b6c438857d078fb553a798..89db5ffe4cf602691632743a11a86e925baccd8e 100644
--- a/pallets/identity/src/benchmarking.rs
+++ b/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,128 +31,146 @@ use sp_runtime::{AccountId32, MultiSigner};
use crate::Pallet;
-const SEED: u32 = 1;
-
-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::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::*;
-struct Account<T: Config> {
- key: T::AccountId,
- index: T::IdtyIndex,
- origin: <T as frame_system::Config>::RuntimeOrigin,
- // name: IdtyName,
-}
+ fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+ frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+ }
-// Create and confirm one account using Alice authorized account.
-// key, origin, name and index are returned.
-// Alice next_creatable_identity_on is reinitialized at the end so several account can be
-// created in a row.
-fn create_one_identity<T: Config>(owner_key: T::AccountId) -> Result<Account<T>, &'static str> {
- // get Alice account to create identity
- let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::from(1u32))
- .unwrap()
- .owner_key;
- let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
- RawOrigin::Signed(caller.clone()).into();
- let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin =
- RawOrigin::Signed(owner_key.clone()).into();
- Pallet::<T>::create_identity(caller_origin.clone(), owner_key.clone())?;
- let name = IdtyName("new_identity".into());
- Pallet::<T>::confirm_identity(owner_key_origin.clone(), name.clone())?;
- let idty_index = IdentityIndexOf::<T>::get(&owner_key).unwrap();
- // make identity member
- <Identities<T>>::mutate_exists(idty_index, |idty_val_opt| {
- if let Some(ref mut idty_val) = idty_val_opt {
- idty_val.status = IdtyStatus::Member;
- }
- });
- // Reset next_creatable_identity_on to add more identities with Alice
- <Identities<T>>::mutate_exists(T::IdtyIndex::from(1u32), |idty_val_opt| {
- if let Some(ref mut idty_val) = idty_val_opt {
- idty_val.next_creatable_identity_on = BlockNumberFor::<T>::zero();
- }
- });
- Ok(Account {
- key: owner_key,
- index: idty_index,
- origin: owner_key_origin,
- // name: name,
- })
-}
+ struct Account<T: Config> {
+ key: T::AccountId,
+ index: T::IdtyIndex,
+ origin: <T as frame_system::Config>::RuntimeOrigin,
+ }
-// 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 next_scheduled = BlockNumberFor::<T>::zero();
- let value = IdtyValue {
- data: Default::default(),
- next_creatable_identity_on: BlockNumberFor::<T>::zero(),
- old_owner_key: None,
- owner_key: owner_key.clone(),
- next_scheduled,
- status: IdtyStatus::Unvalidated,
- };
- let name = i.to_le_bytes();
- let idty_name = IdtyName(name.into());
- <Identities<T>>::insert(idty_index, value);
- IdentityChangeSchedule::<T>::append(next_scheduled, idty_index);
- IdentityIndexOf::<T>::insert(owner_key.clone(), idty_index);
- <IdentitiesNames<T>>::insert(idty_name.clone(), idty_index);
- Ok(())
-}
+ // Create and confirm one account using Alice authorized account.
+ // key, origin, name and index are returned.
+ // Alice next_creatable_identity_on is reinitialized at the end so several account can be
+ // created in a row.
+ fn create_one_identity<T: Config>(owner_key: T::AccountId) -> Result<Account<T>, &'static str> {
+ // get Alice account to create identity
+ let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::from(1u32))
+ .unwrap()
+ .owner_key;
+ let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
+ RawOrigin::Signed(caller.clone()).into();
+ let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin =
+ RawOrigin::Signed(owner_key.clone()).into();
+ Pallet::<T>::create_identity(caller_origin.clone(), owner_key.clone())?;
+ let name = IdtyName("new_identity".into());
+ Pallet::<T>::confirm_identity(owner_key_origin.clone(), name.clone())?;
+ let idty_index = IdentityIndexOf::<T>::get(&owner_key).unwrap();
+ // make identity member
+ <Identities<T>>::mutate_exists(idty_index, |idty_val_opt| {
+ if let Some(ref mut idty_val) = idty_val_opt {
+ idty_val.status = IdtyStatus::Member;
+ }
+ });
+ // Reset next_creatable_identity_on to add more identities with Alice
+ <Identities<T>>::mutate_exists(T::IdtyIndex::from(1u32), |idty_val_opt| {
+ if let Some(ref mut idty_val) = idty_val_opt {
+ idty_val.next_creatable_identity_on = BlockNumberFor::<T>::zero();
+ }
+ });
+ Ok(Account {
+ key: owner_key,
+ index: idty_index,
+ origin: owner_key_origin,
+ // name: name,
+ })
+ }
-// Add `i` dummy identities.
-fn create_identities<T: Config>(i: u32) -> Result<(), &'static str> {
- let identities_count = Pallet::<T>::identities_count();
- for j in 0..i {
- create_dummy_identity::<T>(j + identities_count + 1)?;
+ // 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, 1);
+ let next_scheduled = BlockNumberFor::<T>::zero();
+ let value = IdtyValue {
+ data: Default::default(),
+ next_creatable_identity_on: BlockNumberFor::<T>::zero(),
+ old_owner_key: None,
+ owner_key: owner_key.clone(),
+ next_scheduled,
+ status: IdtyStatus::Unvalidated,
+ };
+ let name = i.to_le_bytes();
+ let idty_name = IdtyName(name.into());
+ <Identities<T>>::insert(idty_index, value);
+ IdentityChangeSchedule::<T>::append(next_scheduled, idty_index);
+ IdentityIndexOf::<T>::insert(owner_key.clone(), idty_index);
+ <IdentitiesNames<T>>::insert(idty_name.clone(), idty_index);
+ Ok(())
}
- assert!(
- identities_count + i == Pallet::<T>::identities_count(),
- "Identities not created"
- );
- 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>,
+ // Add `i` dummy identities.
+ fn create_identities<T: Config>(i: u32) -> Result<(), &'static str> {
+ let identities_count = Pallet::<T>::identities_count();
+ for j in 0..i {
+ create_dummy_identity::<T>(j + identities_count + 1)?;
+ }
+ assert!(
+ identities_count + i == Pallet::<T>::identities_count(),
+ "Identities not created"
+ );
+ Ok(())
}
- // create identity
- 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 {
+ #[benchmark]
+ fn create_identity() {
+ let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key; // Alice
+ 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 {
- 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();
+ #[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, 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(())
}
- // The complexity depends on the number of identities to prune
- prune_item_identities_names {
+ #[benchmark]
+ fn prune_item_identities_names(i: Linear<2, 1_000>) -> Result<(), BenchmarkError> {
+ // The complexity depends on the number of identities to prune
// 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();
- // Base weight of an empty initialize
- on_initialize {
- }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
+ #[extrinsic_call]
+ _(alice_origin, bob, signature);
- // --- do revoke identity
- do_revoke_identity_noop {
+ Ok(())
+ }
+
+ #[benchmark]
+ fn on_initialize() {
+ // Base weight of an empty initialize
+ #[block]
+ {
+ Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
+ }
+ }
+
+ #[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| {
+ 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| {
+ 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 {
- index: 1,
- name: IdtyName::from("Alice"),
- value: IdtyValue {
- data: (),
- next_creatable_identity_on: 0,
- old_owner_key: None,
- owner_key: account("Alice", 1, SEED),
- next_scheduled: 0,
- status: crate::IdtyStatus::Member,
+ crate::mock::new_test_ext(crate::mock::IdentityConfig {
+ identities: vec![
+ crate::GenesisIdty {
+ index: 1,
+ name: crate::IdtyName::from("Alice"),
+ value: crate::IdtyValue {
+ data: (),
+ next_creatable_identity_on: 0,
+ old_owner_key: None,
+ owner_key: frame_benchmarking::account("Alice", 1, 1),
+ next_scheduled: 0,
+ status: crate::IdtyStatus::Member,
+ },
},
- },
- GenesisIdty {
- index: 2,
- name: IdtyName::from("Bob"),
- value: IdtyValue {
- data: (),
- next_creatable_identity_on: 0,
- old_owner_key: None,
- owner_key: account("Bob", 1, SEED),
- next_scheduled: 0,
- status: crate::IdtyStatus::Unconfirmed,
+ crate::GenesisIdty {
+ index: 2,
+ name: crate::IdtyName::from("Bob"),
+ value: crate::IdtyValue {
+ data: (),
+ next_creatable_identity_on: 0,
+ old_owner_key: None,
+ owner_key: frame_benchmarking::account("Bob", 1, 1),
+ next_scheduled: 0,
+ status: crate::IdtyStatus::Unconfirmed,
+ },
},
- },
- ]}),
+ ]
+ }),
crate::mock::Test,
);
}
diff --git a/pallets/membership/src/benchmarking.rs b/pallets/membership/src/benchmarking.rs
index a3475c7d031209aa5f8b2820e0e5a4536e139e88..0f2be6c80895b9548bc523acd5b1720e92b01fd7 100644
--- a/pallets/membership/src/benchmarking.rs
+++ b/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
);
}