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..353fdfd1619953f3246cee1e5d6235cdc24872c3 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());
+ Pallet::<T>::do_add_cert_checked(issuer, receiver, false)?;
+
+ #[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);
+ }
+ }
}