git.delta.rocks / unique-network / refs/commits / 4950cbc3976b

--- a/pallets/app-promotion/src/benchmarking.rs
+++ b/pallets/app-promotion/src/benchmarking.rs
@@ -16,15 +16,24 @@
 
 #![cfg(feature = "runtime-benchmarks")]
 
-use frame_benchmarking::{account, benchmarks};
-use frame_support::traits::{fungible::Unbalanced, OnInitialize};
-use frame_system::RawOrigin;
+use frame_benchmarking::v2::*;
+use frame_support::traits::{
+	fungible::{Inspect, Mutate, Unbalanced},
+	OnInitialize,
+};
+use frame_system::{pallet_prelude::*, RawOrigin};
+use pallet_evm::account::CrossAccountId;
 use pallet_evm_migration::Pallet as EvmMigrationPallet;
 use pallet_unique::benchmarking::create_nft_collection;
-use sp_runtime::traits::Bounded;
+use sp_core::{Get, H160};
+use sp_runtime::{
+	traits::{BlockNumberProvider, Bounded},
+	Perbill,
+};
+use sp_std::{iter::Sum, vec, vec::Vec};
 
-use super::*;
-use crate::Pallet as PromototionPallet;
+use super::{BalanceOf, Call, Config, Pallet, Staked, PENDING_LIMIT_PER_BLOCK};
+use crate::{pallet, Pallet as PromototionPallet};
 
 const SEED: u32 = 0;
 
@@ -49,55 +58,98 @@
 	Ok(pallet_admin)
 }
 
-benchmarks! {
-	where_clause{
-		where T:  Config + pallet_unique::Config + pallet_evm_migration::Config ,
+#[benchmarks(
+	where T:  Config + pallet_unique::Config + pallet_evm_migration::Config ,
 		BlockNumberFor<T>: From<u32> + Into<u32>,
 		BalanceOf<T>: Sum + From<u128>
-	}
+)]
+mod benchmarks {
+	use super::*;
 
-	on_initialize {
-		let b in 0..PENDING_LIMIT_PER_BLOCK;
+	#[benchmark]
+	fn on_initialize(b: Linear<0, PENDING_LIMIT_PER_BLOCK>) -> Result<(), BenchmarkError> {
 		set_admin::<T>()?;
 
 		(0..b).try_for_each(|index| {
 			let staker = account::<T::AccountId>("staker", index, SEED);
-			<T as Config>::Currency::write_balance(&staker,  Into::<BalanceOf<T>>::into(10_000u128) * T::Nominal::get())?;
-			PromototionPallet::<T>::stake(RawOrigin::Signed(staker.clone()).into(), Into::<BalanceOf<T>>::into(100u128) * T::Nominal::get())?;
+			<T as Config>::Currency::write_balance(
+				&staker,
+				Into::<BalanceOf<T>>::into(10_000u128) * T::Nominal::get(),
+			)?;
+			PromototionPallet::<T>::stake(
+				RawOrigin::Signed(staker.clone()).into(),
+				Into::<BalanceOf<T>>::into(100u128) * T::Nominal::get(),
+			)?;
 			PromototionPallet::<T>::unstake_all(RawOrigin::Signed(staker).into())?;
 			Result::<(), sp_runtime::DispatchError>::Ok(())
 		})?;
-		let block_number = <frame_system::Pallet<T>>::current_block_number() + T::PendingInterval::get();
-	}: {PromototionPallet::<T>::on_initialize(block_number)}
+		let block_number =
+			<frame_system::Pallet<T>>::current_block_number() + T::PendingInterval::get();
+
+		#[block]
+		{
+			PromototionPallet::<T>::on_initialize(block_number);
+		}
+
+		Ok(())
+	}
 
-	set_admin_address {
+	#[benchmark]
+	fn set_admin_address() -> Result<(), BenchmarkError> {
 		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
-		let _ = <T as Config>::Currency::set_balance(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-	} : _(RawOrigin::Root, T::CrossAccountId::from_sub(pallet_admin))
+		let _ = <T as Config>::Currency::set_balance(
+			&pallet_admin,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, T::CrossAccountId::from_sub(pallet_admin));
 
-	payout_stakers{
-		let b in 1..100;
+		Ok(())
+	}
 
+	#[benchmark]
+	fn payout_stakers(b: Linear<0, 100>) -> Result<(), BenchmarkError> {
 		let pallet_admin = account::<T::AccountId>("admin", 1, SEED);
-		let share = Perbill::from_rational(1u32, 20);
-		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
-		<T as Config>::Currency::write_balance(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value())?;
-		<T as Config>::Currency::write_balance(&<T as pallet::Config>::TreasuryAccountId::get(),  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value())?;
+		PromototionPallet::<T>::set_admin_address(
+			RawOrigin::Root.into(),
+			T::CrossAccountId::from_sub(pallet_admin.clone()),
+		)?;
+		<T as Config>::Currency::write_balance(
+			&pallet_admin,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		)?;
+		<T as Config>::Currency::write_balance(
+			&<T as pallet::Config>::TreasuryAccountId::get(),
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		)?;
 
-		let stakers: Vec<T::AccountId> = (0..b).map(|index| account("staker", index, SEED)).collect();
+		let stakers: Vec<T::AccountId> =
+			(0..b).map(|index| account("staker", index, SEED)).collect();
 		stakers.iter().try_for_each(|staker| {
-			<T as Config>::Currency::write_balance(staker,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value())?;
+			<T as Config>::Currency::write_balance(
+				staker,
+				Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+			)?;
 			Result::<(), sp_runtime::DispatchError>::Ok(())
 		})?;
 		(1..11).try_for_each(|i| {
 			<frame_system::Pallet<T>>::set_block_number(i.into());
-			T::RelayBlockNumberProvider::set_block_number((2*i).into());
+			T::RelayBlockNumberProvider::set_block_number((2 * i).into());
 			assert_eq!(<frame_system::Pallet<T>>::block_number(), i.into());
-			assert_eq!(T::RelayBlockNumberProvider::current_block_number(), (2*i).into());
-			stakers.iter()
-			.map(|staker| {
-				PromototionPallet::<T>::stake(RawOrigin::Signed(staker.clone()).into(), Into::<BalanceOf<T>>::into(100u128) * T::Nominal::get())
-			}).collect::<Result<Vec<_>, _>>()?;
+			assert_eq!(
+				T::RelayBlockNumberProvider::current_block_number(),
+				(2 * i).into()
+			);
+			stakers
+				.iter()
+				.map(|staker| {
+					PromototionPallet::<T>::stake(
+						RawOrigin::Signed(staker.clone()).into(),
+						Into::<BalanceOf<T>>::into(100u128) * T::Nominal::get(),
+					)
+				})
+				.collect::<Result<Vec<_>, _>>()?;
 
 			Result::<(), sp_runtime::DispatchError>::Ok(())
 		})?;
@@ -107,83 +159,195 @@
 
 		<frame_system::Pallet<T>>::set_block_number(15_000.into());
 		T::RelayBlockNumberProvider::set_block_number(30_000.into());
-	} : _(RawOrigin::Signed(pallet_admin.clone()), Some(b as u8))
 
-	stake {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(pallet_admin.clone()), Some(b as u8));
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn stake() -> Result<(), BenchmarkError> {
 		let caller = account::<T::AccountId>("caller", 0, SEED);
 		let share = Perbill::from_rational(1u32, 10);
-		let _ = <T as Config>::Currency::write_balance(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-	} : _(RawOrigin::Signed(caller.clone()), share * <T as Config>::Currency::total_balance(&caller))
 
-	unstake_all {
+		let _ = <T as Config>::Currency::write_balance(
+			&caller,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			share * <T as Config>::Currency::total_balance(&caller),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn unstake_all() -> Result<(), BenchmarkError> {
 		let caller = account::<T::AccountId>("caller", 0, SEED);
 		let share = Perbill::from_rational(1u32, 20);
-		let _ = <T as Config>::Currency::write_balance(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-		(1..11).map(|i| {
-			// used to change block number
-			<frame_system::Pallet<T>>::set_block_number(i.into());
-			T::RelayBlockNumberProvider::set_block_number((2*i).into());
-			assert_eq!(<frame_system::Pallet<T>>::block_number(), i.into());
-			assert_eq!(T::RelayBlockNumberProvider::current_block_number(), (2*i).into());
-			PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))
-		}).collect::<Result<Vec<_>, _>>()?;
+		let _ = <T as Config>::Currency::write_balance(
+			&caller,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
+		(1..11)
+			.map(|i| {
+				// used to change block number
+				<frame_system::Pallet<T>>::set_block_number(i.into());
+				T::RelayBlockNumberProvider::set_block_number((2 * i).into());
+				assert_eq!(<frame_system::Pallet<T>>::block_number(), i.into());
+				assert_eq!(
+					T::RelayBlockNumberProvider::current_block_number(),
+					(2 * i).into()
+				);
+				PromototionPallet::<T>::stake(
+					RawOrigin::Signed(caller.clone()).into(),
+					share * <T as Config>::Currency::total_balance(&caller),
+				)
+			})
+			.collect::<Result<Vec<_>, _>>()?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
 
-	} : _(RawOrigin::Signed(caller.clone()))
+		Ok(())
+	}
 
-	unstake_partial {
+	#[benchmark]
+	fn unstake_partial() -> Result<(), BenchmarkError> {
 		let caller = account::<T::AccountId>("caller", 0, SEED);
-		let share = Perbill::from_rational(1u32, 20);
-		let _ = <T as Config>::Currency::write_balance(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-		(1..11).map(|i| {
-			// used to change block number
-			<frame_system::Pallet<T>>::set_block_number(i.into());
-			T::RelayBlockNumberProvider::set_block_number((2*i).into());
-			assert_eq!(<frame_system::Pallet<T>>::block_number(), i.into());
-			assert_eq!(T::RelayBlockNumberProvider::current_block_number(), (2*i).into());
-			PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), Into::<BalanceOf<T>>::into(100u128) * T::Nominal::get())
-		}).collect::<Result<Vec<_>, _>>()?;
+		let _ = <T as Config>::Currency::write_balance(
+			&caller,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
+		(1..11)
+			.map(|i| {
+				// used to change block number
+				<frame_system::Pallet<T>>::set_block_number(i.into());
+				T::RelayBlockNumberProvider::set_block_number((2 * i).into());
+				assert_eq!(<frame_system::Pallet<T>>::block_number(), i.into());
+				assert_eq!(
+					T::RelayBlockNumberProvider::current_block_number(),
+					(2 * i).into()
+				);
+				PromototionPallet::<T>::stake(
+					RawOrigin::Signed(caller.clone()).into(),
+					Into::<BalanceOf<T>>::into(100u128) * T::Nominal::get(),
+				)
+			})
+			.collect::<Result<Vec<_>, _>>()?;
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			Into::<BalanceOf<T>>::into(1000u128) * T::Nominal::get(),
+		);
 
-	} : _(RawOrigin::Signed(caller.clone()), Into::<BalanceOf<T>>::into(1000u128) * T::Nominal::get())
+		Ok(())
+	}
 
-	sponsor_collection {
+	#[benchmark]
+	fn sponsor_collection() -> Result<(), BenchmarkError> {
 		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
-		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
-		let _ = <T as Config>::Currency::write_balance(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		PromototionPallet::<T>::set_admin_address(
+			RawOrigin::Root.into(),
+			T::CrossAccountId::from_sub(pallet_admin.clone()),
+		)?;
+		let _ = <T as Config>::Currency::write_balance(
+			&pallet_admin,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
 		let caller: T::AccountId = account("caller", 0, SEED);
-		let _ = <T as Config>::Currency::write_balance(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = <T as Config>::Currency::write_balance(
+			&caller,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
 		let collection = create_nft_collection::<T>(caller)?;
-	} : _(RawOrigin::Signed(pallet_admin.clone()), collection)
 
-	stop_sponsoring_collection {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(pallet_admin.clone()), collection);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn stop_sponsoring_collection() -> Result<(), BenchmarkError> {
 		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
-		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
-		let _ = <T as Config>::Currency::write_balance(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		PromototionPallet::<T>::set_admin_address(
+			RawOrigin::Root.into(),
+			T::CrossAccountId::from_sub(pallet_admin.clone()),
+		)?;
+		let _ = <T as Config>::Currency::write_balance(
+			&pallet_admin,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
 		let caller: T::AccountId = account("caller", 0, SEED);
-		let _ = <T as Config>::Currency::write_balance(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = <T as Config>::Currency::write_balance(
+			&caller,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
 		let collection = create_nft_collection::<T>(caller)?;
-		PromototionPallet::<T>::sponsor_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?;
-	} : _(RawOrigin::Signed(pallet_admin.clone()), collection)
+		PromototionPallet::<T>::sponsor_collection(
+			RawOrigin::Signed(pallet_admin.clone()).into(),
+			collection,
+		)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(pallet_admin.clone()), collection);
+
+		Ok(())
+	}
 
-	sponsor_contract {
+	#[benchmark]
+	fn sponsor_contract() -> Result<(), BenchmarkError> {
 		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
-		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
+		PromototionPallet::<T>::set_admin_address(
+			RawOrigin::Root.into(),
+			T::CrossAccountId::from_sub(pallet_admin.clone()),
+		)?;
 
-		let _ = <T as Config>::Currency::write_balance(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = <T as Config>::Currency::write_balance(
+			&pallet_admin,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
 		let address = H160::from_low_u64_be(SEED as u64);
 		let data: Vec<u8> = (0..20).collect();
 		<EvmMigrationPallet<T>>::begin(RawOrigin::Root.into(), address)?;
 		<EvmMigrationPallet<T>>::finish(RawOrigin::Root.into(), address, data)?;
-	} : _(RawOrigin::Signed(pallet_admin.clone()), address)
 
-	stop_sponsoring_contract {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(pallet_admin.clone()), address);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn stop_sponsoring_contract() -> Result<(), BenchmarkError> {
 		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
-		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
+		PromototionPallet::<T>::set_admin_address(
+			RawOrigin::Root.into(),
+			T::CrossAccountId::from_sub(pallet_admin.clone()),
+		)?;
 
-		let _ = <T as Config>::Currency::write_balance(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = <T as Config>::Currency::write_balance(
+			&pallet_admin,
+			Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value(),
+		);
 		let address = H160::from_low_u64_be(SEED as u64);
 		let data: Vec<u8> = (0..20).collect();
 		<EvmMigrationPallet<T>>::begin(RawOrigin::Root.into(), address)?;
 		<EvmMigrationPallet<T>>::finish(RawOrigin::Root.into(), address, data)?;
-		PromototionPallet::<T>::sponsor_contract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?;
-	} : _(RawOrigin::Signed(pallet_admin.clone()), address)
+		PromototionPallet::<T>::sponsor_contract(
+			RawOrigin::Signed(pallet_admin.clone()).into(),
+			address,
+		)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(pallet_admin.clone()), address);
+
+		Ok(())
+	}
 }

--- a/pallets/common/src/benchmarking.rs
+++ b/pallets/common/src/benchmarking.rs
@@ -18,7 +18,7 @@
 
 use core::convert::TryInto;
 
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::{account, v2::*};
 use frame_support::{
 	pallet_prelude::ConstU32,
 	traits::{fungible::Balanced, tokens::Precision, Get, Imbalance},
@@ -26,7 +26,7 @@
 };
 use pallet_evm::account::CrossAccountId;
 use sp_runtime::{traits::Zero, DispatchError};
-use sp_std::vec::Vec;
+use sp_std::{vec, vec::Vec};
 use up_data_structs::{
 	AccessMode, CollectionId, CollectionMode, CollectionPermissions, CreateCollectionData,
 	NestingPermissions, PropertiesPermissionMap, Property, PropertyKey, PropertyValue,
@@ -178,62 +178,103 @@
 	() => {}
 }
 
-benchmarks! {
-	set_collection_properties {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn set_collection_properties(
+		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
+	) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
-		let props = (0..b).map(|p| Property {
-			key: property_key(p as usize),
-			value: property_value(),
-		}).collect::<Vec<_>>();
-	}: {<Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?}
+		let props = (0..b)
+			.map(|p| Property {
+				key: property_key(p as usize),
+				value: property_value(),
+			})
+			.collect::<Vec<_>>();
+
+		#[block]
+		{
+			<Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?;
+		}
+
+		Ok(())
+	}
 
-	delete_collection_properties {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+	#[benchmark]
+	fn delete_collection_properties(
+		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
+	) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
-		let props = (0..b).map(|p| Property {
-			key: property_key(p as usize),
-			value: property_value(),
-		}).collect::<Vec<_>>();
+		let props = (0..b)
+			.map(|p| Property {
+				key: property_key(p as usize),
+				value: property_value(),
+			})
+			.collect::<Vec<_>>();
 		<Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?;
 		let to_delete = (0..b).map(|p| property_key(p as usize)).collect::<Vec<_>>();
-	}: {<Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete.into_iter())?}
 
-	check_accesslist{
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete.into_iter())?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn check_accesslist() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner);
 		};
 
 		let mut collection_handle = <CollectionHandle<T>>::try_get(collection.id)?;
-			<Pallet<T>>::update_permissions(
-				&sender,
-				&mut collection_handle,
-				CollectionPermissions { access: Some(AccessMode::AllowList), ..Default::default() }
-			)?;
+		<Pallet<T>>::update_permissions(
+			&sender,
+			&mut collection_handle,
+			CollectionPermissions {
+				access: Some(AccessMode::AllowList),
+				..Default::default()
+			},
+		)?;
 
-		<Pallet<T>>::toggle_allowlist(
-				&collection,
-				&sender,
-				&sender,
-				true,
-			)?;
+		<Pallet<T>>::toggle_allowlist(&collection, &sender, &sender, true)?;
 
-		assert_eq!(collection_handle.permissions.access(), AccessMode::AllowList);
+		assert_eq!(
+			collection_handle.permissions.access(),
+			AccessMode::AllowList
+		);
+
+		#[block]
+		{
+			collection_handle.check_allowlist(&sender)?;
+		}
 
-	}: {collection_handle.check_allowlist(&sender)?;}
+		Ok(())
+	}
 
-	init_token_properties_common {
-		bench_init!{
+	#[benchmark]
+	fn init_token_properties_common() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: sub;
 			sender: cross_from_sub(sender);
 		};
-	}: {load_is_admin_and_property_permissions(&collection, &sender);}
+
+		#[block]
+		{
+			load_is_admin_and_property_permissions(&collection, &sender);
+		}
+
+		Ok(())
+	}
 }

--- a/pallets/configuration/src/benchmarking.rs
+++ b/pallets/configuration/src/benchmarking.rs
@@ -16,9 +16,10 @@
 
 //! Benchmarking setup for pallet-configuration
 
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_support::assert_ok;
 use frame_system::{pallet_prelude::*, EventRecord, RawOrigin};
+use sp_std::vec;
 
 use super::*;
 
@@ -30,66 +31,117 @@
 	assert_eq!(event, &system_event);
 }
 
-benchmarks! {
-	where_clause { where
+#[benchmarks(
+	where
 		T: Config,
 		T::Balance: From<u32>
-	}
+)]
+mod benchmarks {
+	use super::*;
 
-	set_weight_to_fee_coefficient_override {
+	#[benchmark]
+	fn set_weight_to_fee_coefficient_override() -> Result<(), BenchmarkError> {
 		let coeff: u64 = 999;
-	}: {
-		assert_ok!(
-			<Pallet<T>>::set_weight_to_fee_coefficient_override(RawOrigin::Root.into(), Some(coeff))
-		);
+
+		#[block]
+		{
+			assert_ok!(<Pallet<T>>::set_weight_to_fee_coefficient_override(
+				RawOrigin::Root.into(),
+				Some(coeff)
+			));
+		}
+
+		Ok(())
 	}
 
-	set_min_gas_price_override {
+	#[benchmark]
+	fn set_min_gas_price_override() -> Result<(), BenchmarkError> {
 		let coeff: u64 = 999;
-	}: {
-		assert_ok!(
-			<Pallet<T>>::set_min_gas_price_override(RawOrigin::Root.into(), Some(coeff))
-		);
+
+		#[block]
+		{
+			assert_ok!(<Pallet<T>>::set_min_gas_price_override(
+				RawOrigin::Root.into(),
+				Some(coeff)
+			));
+		}
+
+		Ok(())
 	}
 
-	set_app_promotion_configuration_override {
+	#[benchmark]
+	fn set_app_promotion_configuration_override() -> Result<(), BenchmarkError> {
 		let configuration: AppPromotionConfiguration<BlockNumberFor<T>> = Default::default();
-	}: {
-		assert_ok!(
-			<Pallet<T>>::set_app_promotion_configuration_override(RawOrigin::Root.into(), configuration)
-		);
+
+		#[block]
+		{
+			assert_ok!(<Pallet<T>>::set_app_promotion_configuration_override(
+				RawOrigin::Root.into(),
+				configuration
+			));
+		}
+
+		Ok(())
 	}
 
-	set_collator_selection_desired_collators {
+	#[benchmark]
+	fn set_collator_selection_desired_collators() -> Result<(), BenchmarkError> {
 		let max: u32 = 999;
-	}: {
-		assert_ok!(
-			<Pallet<T>>::set_collator_selection_desired_collators(RawOrigin::Root.into(), Some(max))
+
+		#[block]
+		{
+			assert_ok!(<Pallet<T>>::set_collator_selection_desired_collators(
+				RawOrigin::Root.into(),
+				Some(max)
+			));
+		}
+
+		assert_last_event::<T>(
+			Event::NewDesiredCollators {
+				desired_collators: Some(max),
+			}
+			.into(),
 		);
+
+		Ok(())
 	}
-	verify {
-		assert_last_event::<T>(Event::NewDesiredCollators{desired_collators: Some(max)}.into());
-	}
 
-	set_collator_selection_license_bond {
+	#[benchmark]
+	fn set_collator_selection_license_bond() -> Result<(), BenchmarkError> {
 		let bond_cost: Option<T::Balance> = Some(1000u32.into());
-	}: {
-		assert_ok!(
-			<Pallet<T>>::set_collator_selection_license_bond(RawOrigin::Root.into(), bond_cost)
-		);
-	}
-	verify {
-		assert_last_event::<T>(Event::NewCollatorLicenseBond{bond_cost}.into());
+
+		#[block]
+		{
+			assert_ok!(<Pallet<T>>::set_collator_selection_license_bond(
+				RawOrigin::Root.into(),
+				bond_cost
+			));
+		}
+
+		assert_last_event::<T>(Event::NewCollatorLicenseBond { bond_cost }.into());
+
+		Ok(())
 	}
 
-	set_collator_selection_kick_threshold {
+	#[benchmark]
+	fn set_collator_selection_kick_threshold() -> Result<(), BenchmarkError> {
 		let threshold: Option<BlockNumberFor<T>> = Some(900u32.into());
-	}: {
-		assert_ok!(
-			<Pallet<T>>::set_collator_selection_kick_threshold(RawOrigin::Root.into(), threshold)
+
+		#[block]
+		{
+			assert_ok!(<Pallet<T>>::set_collator_selection_kick_threshold(
+				RawOrigin::Root.into(),
+				threshold
+			));
+		}
+
+		assert_last_event::<T>(
+			Event::NewCollatorKickThreshold {
+				length_in_blocks: threshold,
+			}
+			.into(),
 		);
-	}
-	verify {
-		assert_last_event::<T>(Event::NewCollatorKickThreshold{length_in_blocks: threshold}.into());
+
+		Ok(())
 	}
 }

--- a/pallets/evm-migration/src/benchmarking.rs
+++ b/pallets/evm-migration/src/benchmarking.rs
@@ -16,21 +16,29 @@
 
 #![allow(missing_docs)]
 
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
 use sp_core::{H160, H256};
 use sp_std::{vec, vec::Vec};
 
 use super::{Call, Config, Pallet};
 
-benchmarks! {
-	where_clause { where <T as Config>::RuntimeEvent: parity_scale_codec::Encode }
+#[benchmarks(
+	where <T as Config>::RuntimeEvent: parity_scale_codec::Encode
+)]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn begin() -> Result<(), BenchmarkError> {
+		#[extrinsic_call]
+		_(RawOrigin::Root, H160::default());
 
-	begin {
-	}: _(RawOrigin::Root, H160::default())
+		Ok(())
+	}
 
-	set_data {
-		let b in 0..80;
+	#[benchmark]
+	fn set_data(b: Linear<0, 80>) -> Result<(), BenchmarkError> {
 		let address = H160::from_low_u64_be(b as u64);
 		let mut data = Vec::new();
 		for i in 0..b {
@@ -40,27 +48,51 @@
 			));
 		}
 		<Pallet<T>>::begin(RawOrigin::Root.into(), address)?;
-	}: _(RawOrigin::Root, address, data)
 
-	finish {
-		let b in 0..80;
+		#[extrinsic_call]
+		_(RawOrigin::Root, address, data);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn finish(b: Linear<0, 80>) -> Result<(), BenchmarkError> {
 		let address = H160::from_low_u64_be(b as u64);
 		let data: Vec<u8> = (0..b as u8).collect();
 		<Pallet<T>>::begin(RawOrigin::Root.into(), address)?;
-	}: _(RawOrigin::Root, address, data)
 
-	insert_eth_logs {
-		let b in 0..200;
-		let logs = (0..b).map(|_| ethereum::Log {
-			address: H160([b as u8; 20]),
-			data: vec![b as u8; 128],
-			topics: vec![H256([b as u8; 32]); 6],
-		}).collect::<Vec<_>>();
-	}: _(RawOrigin::Root, logs)
+		#[extrinsic_call]
+		_(RawOrigin::Root, address, data);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn insert_eth_logs(b: Linear<0, 200>) -> Result<(), BenchmarkError> {
+		let logs = (0..b)
+			.map(|_| ethereum::Log {
+				address: H160([b as u8; 20]),
+				data: vec![b as u8; 128],
+				topics: vec![H256([b as u8; 32]); 6],
+			})
+			.collect::<Vec<_>>();
 
-	insert_events {
-		let b in 0..200;
+		#[extrinsic_call]
+		_(RawOrigin::Root, logs);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn insert_events(b: Linear<0, 200>) -> Result<(), BenchmarkError> {
 		use parity_scale_codec::Encode;
-		let logs = (0..b).map(|_| <T as Config>::RuntimeEvent::from(crate::Event::<T>::TestEvent).encode()).collect::<Vec<_>>();
-	}: _(RawOrigin::Root, logs)
+		let logs = (0..b)
+			.map(|_| <T as Config>::RuntimeEvent::from(crate::Event::<T>::TestEvent).encode())
+			.collect::<Vec<_>>();
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, logs);
+
+		Ok(())
+	}
 }

--- a/pallets/foreign-assets/src/benchmarking.rs
+++ b/pallets/foreign-assets/src/benchmarking.rs
@@ -16,10 +16,10 @@
 
 #![allow(missing_docs)]
 
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::{account, v2::*};
 use frame_support::traits::Currency;
 use frame_system::RawOrigin;
-use sp_std::{boxed::Box, vec::Vec};
+use sp_std::{boxed::Box, vec, vec::Vec};
 use staging_xcm::{opaque::latest::Junction::Parachain, v3::Junctions::X1, VersionedMultiLocation};
 
 use super::{Call, Config, Pallet};
@@ -31,42 +31,74 @@
 		.unwrap()
 }
 
-benchmarks! {
-	register_foreign_asset {
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn register_foreign_asset() -> Result<(), BenchmarkError> {
 		let owner: T::AccountId = account("user", 0, 1);
 		let location: VersionedMultiLocation = VersionedMultiLocation::from(X1(Parachain(1000)));
-		let metadata: AssetMetadata<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance> = AssetMetadata{
+		let metadata: AssetMetadata<
+			<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance,
+		> = AssetMetadata {
 			name: bounded(b"name"),
 			symbol: bounded(b"symbol"),
 			decimals: 18,
-			minimal_balance: 1u32.into()
+			minimal_balance: 1u32.into(),
 		};
-		let mut balance: <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance =
-		   4_000_000_000u32.into();
+		let mut balance: <<T as Config>::Currency as Currency<
+			<T as frame_system::Config>::AccountId,
+		>>::Balance = 4_000_000_000u32.into();
 		balance = balance * balance;
-		<T as Config>::Currency::make_free_balance_be(&owner,
-			balance);
-	}: _(RawOrigin::Root, owner, Box::new(location), Box::new(metadata))
+		<T as Config>::Currency::make_free_balance_be(&owner, balance);
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Root,
+			owner,
+			Box::new(location),
+			Box::new(metadata),
+		);
+
+		Ok(())
+	}
 
-	update_foreign_asset {
+	#[benchmark]
+	fn update_foreign_asset() -> Result<(), BenchmarkError> {
 		let owner: T::AccountId = account("user", 0, 1);
 		let location: VersionedMultiLocation = VersionedMultiLocation::from(X1(Parachain(2000)));
-		let metadata: AssetMetadata<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance> = AssetMetadata{
+		let metadata: AssetMetadata<
+			<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance,
+		> = AssetMetadata {
 			name: bounded(b"name"),
 			symbol: bounded(b"symbol"),
 			decimals: 18,
-			minimal_balance: 1u32.into()
+			minimal_balance: 1u32.into(),
 		};
-		let metadata2: AssetMetadata<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance> = AssetMetadata{
+		let metadata2: AssetMetadata<
+			<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance,
+		> = AssetMetadata {
 			name: bounded(b"name2"),
 			symbol: bounded(b"symbol2"),
 			decimals: 18,
-			minimal_balance: 1u32.into()
+			minimal_balance: 1u32.into(),
 		};
-		let mut balance: <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance =
-		   4_000_000_000u32.into();
+		let mut balance: <<T as Config>::Currency as Currency<
+			<T as frame_system::Config>::AccountId,
+		>>::Balance = 4_000_000_000u32.into();
 		balance = balance * balance;
 		<T as Config>::Currency::make_free_balance_be(&owner, balance);
-		Pallet::<T>::register_foreign_asset(RawOrigin::Root.into(), owner, Box::new(location.clone()), Box::new(metadata))?;
-	}: _(RawOrigin::Root, 0, Box::new(location), Box::new(metadata2))
+		Pallet::<T>::register_foreign_asset(
+			RawOrigin::Root.into(),
+			owner,
+			Box::new(location.clone()),
+			Box::new(metadata),
+		)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, 0, Box::new(location), Box::new(metadata2));
+
+		Ok(())
+	}
 }

--- a/pallets/fungible/src/benchmarking.rs
+++ b/pallets/fungible/src/benchmarking.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::{account, v2::*};
 use pallet_common::{bench_init, benchmarking::create_collection_raw};
 use sp_std::prelude::*;
 use up_data_structs::{budget::Unlimited, CollectionMode, MAX_ITEMS_PER_BATCH};
@@ -35,83 +35,159 @@
 	)
 }
 
-benchmarks! {
-	create_item {
-		bench_init!{
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn create_item() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); to: cross_sub;
 		};
-	}: {<Pallet<T>>::create_item(&collection, &sender, (to, 200), &Unlimited)?}
 
-	create_multiple_items_ex {
-		let b in 0..MAX_ITEMS_PER_BATCH;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::create_item(&collection, &sender, (to, 200), &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn create_multiple_items_ex(b: Linear<0, MAX_ITEMS_PER_BATCH>) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner);
 		};
-		let data = (0..b).map(|i| {
-			bench_init!(to: cross_sub(i););
-			(to, 200)
-		}).collect::<BTreeMap<_, _>>();
-	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
+		let data = (0..b)
+			.map(|i| {
+				bench_init!(to: cross_sub(i););
+				(to, 200)
+			})
+			.collect::<BTreeMap<_, _>>();
+
+		#[block]
+		{
+			<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?;
+		}
+
+		Ok(())
+	}
 
-	burn_item {
-		bench_init!{
+	#[benchmark]
+	fn burn_item() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; burner: cross_sub;
 		};
 		<Pallet<T>>::create_item(&collection, &owner, (burner.clone(), 200), &Unlimited)?;
-	}: {<Pallet<T>>::burn(&collection, &burner, 100)?}
 
-	transfer_raw {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::burn(&collection, &burner, 100)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn transfer_raw() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; to: cross_sub;
 		};
 		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
-	}: {<Pallet<T>>::transfer(&collection, &sender, &to, 200, &Unlimited)?}
 
-	approve {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::transfer(&collection, &sender, &to, 200, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn approve() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
 		};
 		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
-	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?}
 
-	approve_from {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance(&collection, &sender, &spender, 100)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn approve_from() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
 
 		};
 		let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth());
 		<Pallet<T>>::create_item(&collection, &owner, (owner_eth.clone(), 200), &Unlimited)?;
-	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, 100)?}
 
-	check_allowed_raw {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, 100)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn check_allowed_raw() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
 		};
 		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &spender, 200)?;
-	}: {<Pallet<T>>::check_allowed(&collection, &spender, &sender, 200, &Unlimited)?;}
 
-	set_allowance_unchecked_raw {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::check_allowed(&collection, &spender, &sender, 200, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_allowance_unchecked_raw() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
 		};
 		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
-	}: {<Pallet<T>>::set_allowance_unchecked(&collection, &sender, &spender, 200);}
 
-	burn_from {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance_unchecked(&collection, &sender, &spender, 200);
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn burn_from() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; burner: cross_sub;
 		};
 		<Pallet<T>>::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &burner, 200)?;
-	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, 100, &Unlimited)?}
+
+		#[block]
+		{
+			<Pallet<T>>::burn_from(&collection, &burner, &sender, 100, &Unlimited)?
+		}
+
+		Ok(())
+	}
 }

--- a/pallets/identity/src/benchmarking.rs
+++ b/pallets/identity/src/benchmarking.rs
@@ -37,11 +37,8 @@
 #![cfg(feature = "runtime-benchmarks")]
 #![allow(clippy::no_effect)]
 
-use frame_benchmarking::{account, benchmarks, whitelisted_caller};
-use frame_support::{
-	assert_ok, ensure,
-	traits::{EnsureOrigin, Get},
-};
+use frame_benchmarking::v2::*;
+use frame_support::{assert_ok, ensure, traits::EnsureOrigin};
 use frame_system::RawOrigin;
 use sp_runtime::traits::Bounded;
 
@@ -145,25 +142,48 @@
 	200u32.into()
 }
 
-benchmarks! {
-	add_registrar {
-		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
-		ensure!(Registrars::<T>::get().len() as u32 == r, "Registrars not set up correctly.");
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	const MAX_REGISTRARS: u32 = 20;
+	const MAX_ADDITIONAL_FIELDS: u32 = 100;
+	const MAX_SUB_ACCOUNTS: u32 = 100;
+
+	#[benchmark]
+	fn add_registrar(r: Linear<2, MAX_REGISTRARS>) -> Result<(), BenchmarkError> {
+		let r = r - 1;
+		add_registrars::<T>(r)?;
+		ensure!(
+			Registrars::<T>::get().len() as u32 == r,
+			"Registrars not set up correctly."
+		);
 		let origin = T::RegistrarOrigin::try_successful_origin().unwrap();
 		let account = T::Lookup::unlookup(account("registrar", r + 1, SEED));
-	}: _<T::RuntimeOrigin>(origin, account)
-	verify {
-		ensure!(Registrars::<T>::get().len() as u32 == r + 1, "Registrars not added.");
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, account);
+
+		ensure!(
+			Registrars::<T>::get().len() as u32 == r + 1,
+			"Registrars not added."
+		);
+
+		Ok(())
 	}
 
-	set_identity {
-		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
-		let x in 0 .. T::MaxAdditionalFields::get();
+	#[benchmark]
+	fn set_identity(
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+		r: Linear<1, MAX_REGISTRARS>,
+	) -> Result<(), BenchmarkError> {
+		add_registrars::<T>(r)?;
 		let caller = {
 			// The target user
 			let caller: T::AccountId = whitelisted_caller();
 			let caller_lookup = T::Lookup::unlookup(caller.clone());
-			let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+			let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
+				RawOrigin::Signed(caller.clone()).into();
 			let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
 			// Add an initial identity
@@ -173,8 +193,7 @@
 			// User requests judgement from all the registrars, and they approve
 			for i in 0..r {
 				let registrar: T::AccountId = account("registrar", i, SEED);
-				let registrar_lookup = T::Lookup::unlookup(registrar.clone());
-				let balance_to_use =  balance_unit::<T>() * 10u32.into();
+				let balance_to_use = balance_unit::<T>() * 10u32.into();
 				let _ = T::Currency::make_free_balance_be(&registrar, balance_to_use);
 
 				Identity::<T>::request_judgement(caller_origin.clone(), i, 10u32.into())?;
@@ -188,66 +207,91 @@
 			}
 			caller
 		};
-	}: _(RawOrigin::Signed(caller.clone()), Box::new(create_identity_info::<T>(x)))
-	verify {
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			Box::new(create_identity_info::<T>(x)),
+		);
+
 		assert_last_event::<T>(Event::<T>::IdentitySet { who: caller }.into());
+
+		Ok(())
 	}
 
 	// We need to split `set_subs` into two benchmarks to accurately isolate the potential
 	// writes caused by new or old sub accounts. The actual weight should simply be
 	// the sum of these two weights.
-	set_subs_new {
+	#[benchmark]
+	fn set_subs_new(s: Linear<0, MAX_SUB_ACCOUNTS>) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
 		// Create a new subs vec with s sub accounts
-		let s in 0 .. T::MaxSubAccounts::get() => ();
 		let subs = create_sub_accounts::<T>(&caller, s)?;
-		ensure!(SubsOf::<T>::get(&caller).1.len() == 0, "Caller already has subs");
-	}: set_subs(RawOrigin::Signed(caller.clone()), subs)
-	verify {
-		ensure!(SubsOf::<T>::get(&caller).1.len() as u32 == s, "Subs not added");
+		ensure!(
+			SubsOf::<T>::get(&caller).1.len() == 0,
+			"Caller already has subs"
+		);
+
+		#[extrinsic_call]
+		set_subs(RawOrigin::Signed(caller.clone()), subs);
+
+		ensure!(
+			SubsOf::<T>::get(&caller).1.len() as u32 == s,
+			"Subs not added"
+		);
+
+		Ok(())
 	}
 
-	set_subs_old {
+	#[benchmark]
+	fn set_subs_old(p: Linear<0, MAX_SUB_ACCOUNTS>) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
 		// Give them p many previous sub accounts.
-		let p in 0 .. T::MaxSubAccounts::get() => {
-			let _ = add_sub_accounts::<T>(&caller, p)?;
-		};
+		let _ = add_sub_accounts::<T>(&caller, p)?;
 		// Remove all subs.
 		let subs = create_sub_accounts::<T>(&caller, 0)?;
 		ensure!(
 			SubsOf::<T>::get(&caller).1.len() as u32 == p,
 			"Caller does have subs",
 		);
-	}: set_subs(RawOrigin::Signed(caller.clone()), subs)
-	verify {
+
+		#[extrinsic_call]
+		set_subs(RawOrigin::Signed(caller.clone()), subs);
+
 		ensure!(SubsOf::<T>::get(&caller).1.len() == 0, "Subs not removed");
+
+		Ok(())
 	}
 
-	clear_identity {
+	#[benchmark]
+	fn clear_identity(
+		r: Linear<1, MAX_REGISTRARS>,
+		s: Linear<0, MAX_SUB_ACCOUNTS>,
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+	) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
-		let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
 		let caller_lookup = <T::Lookup as StaticLookup>::unlookup(caller.clone());
 		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
-		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
-		let s in 0 .. T::MaxSubAccounts::get() => {
+		add_registrars::<T>(r)?;
+
+		{
 			// Give them s many sub accounts
 			let caller: T::AccountId = whitelisted_caller();
 			let _ = add_sub_accounts::<T>(&caller, s)?;
-		};
-		let x in 0 .. T::MaxAdditionalFields::get();
+		}
 
 		// Create their main identity with x additional fields
 		let info = create_identity_info::<T>(x);
 		let caller: T::AccountId = whitelisted_caller();
-		let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
+		let caller_origin =
+			<T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
 		Identity::<T>::set_identity(caller_origin.clone(), Box::new(info.clone()))?;
 
 		// User requests judgement from all the registrars, and they approve
 		for i in 0..r {
 			let registrar: T::AccountId = account("registrar", i, SEED);
-			let balance_to_use =  balance_unit::<T>() * 10u32.into();
+			let balance_to_use = balance_unit::<T>() * 10u32.into();
 			let _ = T::Currency::make_free_balance_be(&registrar, balance_to_use);
 
 			Identity::<T>::request_judgement(caller_origin.clone(), i, 10u32.into())?;
@@ -259,108 +303,199 @@
 				T::Hashing::hash_of(&info),
 			)?;
 		}
-		ensure!(IdentityOf::<T>::contains_key(&caller), "Identity does not exist.");
-	}: _(RawOrigin::Signed(caller.clone()))
-	verify {
-		ensure!(!IdentityOf::<T>::contains_key(&caller), "Identity not cleared.");
+		ensure!(
+			IdentityOf::<T>::contains_key(&caller),
+			"Identity does not exist."
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		ensure!(
+			!IdentityOf::<T>::contains_key(&caller),
+			"Identity not cleared."
+		);
+
+		Ok(())
 	}
 
-	request_judgement {
+	#[benchmark]
+	fn request_judgement(
+		r: Linear<1, MAX_REGISTRARS>,
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+	) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
 		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
-		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
-		let x in 0 .. T::MaxAdditionalFields::get() => {
+		add_registrars::<T>(r)?;
+
+		{
 			// Create their main identity with x additional fields
 			let info = create_identity_info::<T>(x);
 			let caller: T::AccountId = whitelisted_caller();
-			let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller));
+			let caller_origin =
+				<T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller));
 			Identity::<T>::set_identity(caller_origin, Box::new(info))?;
-		};
-	}: _(RawOrigin::Signed(caller.clone()), r - 1, 10u32.into())
-	verify {
-		assert_last_event::<T>(Event::<T>::JudgementRequested { who: caller, registrar_index: r-1 }.into());
+		}
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), r - 1, 10u32.into());
+
+		assert_last_event::<T>(
+			Event::<T>::JudgementRequested {
+				who: caller,
+				registrar_index: r - 1,
+			}
+			.into(),
+		);
+
+		Ok(())
 	}
 
-	cancel_request {
+	#[benchmark]
+	fn cancel_request(
+		r: Linear<1, MAX_REGISTRARS>,
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+	) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
-		let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
+		let caller_origin =
+			<T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
 		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
-		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
-		let x in 0 .. T::MaxAdditionalFields::get() => {
+		add_registrars::<T>(r)?;
+
+		{
 			// Create their main identity with x additional fields
 			let info = create_identity_info::<T>(x);
 			let caller: T::AccountId = whitelisted_caller();
-			let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller));
+			let caller_origin =
+				<T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller));
 			Identity::<T>::set_identity(caller_origin, Box::new(info))?;
-		};
+		}
 
 		Identity::<T>::request_judgement(caller_origin, r - 1, 10u32.into())?;
-	}: _(RawOrigin::Signed(caller.clone()), r - 1)
-	verify {
-		assert_last_event::<T>(Event::<T>::JudgementUnrequested { who: caller, registrar_index: r-1 }.into());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), r - 1);
+
+		assert_last_event::<T>(
+			Event::<T>::JudgementUnrequested {
+				who: caller,
+				registrar_index: r - 1,
+			}
+			.into(),
+		);
+
+		Ok(())
 	}
 
-	set_fee {
+	#[benchmark]
+	fn set_fee(r: Linear<2, MAX_REGISTRARS>) -> Result<(), BenchmarkError> {
+		let r = r - 1;
 		let caller: T::AccountId = whitelisted_caller();
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
 
-		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+		add_registrars::<T>(r)?;
 
 		let registrar_origin = T::RegistrarOrigin::try_successful_origin().unwrap();
 		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
 		let registrars = Registrars::<T>::get();
-		ensure!(registrars[r as usize].as_ref().unwrap().fee == 0u32.into(), "Fee already set.");
-	}: _(RawOrigin::Signed(caller), r, 100u32.into())
-	verify {
+		ensure!(
+			registrars[r as usize].as_ref().unwrap().fee == 0u32.into(),
+			"Fee already set."
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), r, 100u32.into());
+
 		let registrars = Registrars::<T>::get();
-		ensure!(registrars[r as usize].as_ref().unwrap().fee == 100u32.into(), "Fee not changed.");
+		ensure!(
+			registrars[r as usize].as_ref().unwrap().fee == 100u32.into(),
+			"Fee not changed."
+		);
+
+		Ok(())
 	}
 
-	set_account_id {
+	#[benchmark]
+	fn set_account_id(r: Linear<2, MAX_REGISTRARS>) -> Result<(), BenchmarkError> {
+		let r = r - 1;
 		let caller: T::AccountId = whitelisted_caller();
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
 		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
-		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+		add_registrars::<T>(r)?;
 
 		let registrar_origin = T::RegistrarOrigin::try_successful_origin().unwrap();
 		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
 		let registrars = Registrars::<T>::get();
-		ensure!(registrars[r as usize].as_ref().unwrap().account == caller, "id not set.");
+		ensure!(
+			registrars[r as usize].as_ref().unwrap().account == caller,
+			"id not set."
+		);
 		let new_account = T::Lookup::unlookup(account("new", 0, SEED));
-	}: _(RawOrigin::Signed(caller), r, new_account)
-	verify {
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), r, new_account);
+
 		let registrars = Registrars::<T>::get();
-		ensure!(registrars[r as usize].as_ref().unwrap().account == account("new", 0, SEED), "id not changed.");
+		ensure!(
+			registrars[r as usize].as_ref().unwrap().account == account("new", 0, SEED),
+			"id not changed."
+		);
+
+		Ok(())
 	}
 
-	set_fields {
+	#[benchmark]
+	fn set_fields(r: Linear<2, MAX_REGISTRARS>) -> Result<(), BenchmarkError> {
+		let r = r - 1;
 		let caller: T::AccountId = whitelisted_caller();
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
 		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
-		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+		add_registrars::<T>(r)?;
 
 		let registrar_origin = T::RegistrarOrigin::try_successful_origin().unwrap();
 		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
 		let fields = IdentityFields(
-			IdentityField::Display | IdentityField::Legal | IdentityField::Web | IdentityField::Riot
-			| IdentityField::Email | IdentityField::PgpFingerprint | IdentityField::Image | IdentityField::Twitter
+			IdentityField::Display
+				| IdentityField::Legal
+				| IdentityField::Web
+				| IdentityField::Riot
+				| IdentityField::Email
+				| IdentityField::PgpFingerprint
+				| IdentityField::Image
+				| IdentityField::Twitter,
 		);
 		let registrars = Registrars::<T>::get();
-		ensure!(registrars[r as usize].as_ref().unwrap().fields == Default::default(), "fields already set.");
-	}: _(RawOrigin::Signed(caller), r, fields)
-	verify {
+		ensure!(
+			registrars[r as usize].as_ref().unwrap().fields == Default::default(),
+			"fields already set."
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), r, fields);
+
 		let registrars = Registrars::<T>::get();
-		ensure!(registrars[r as usize].as_ref().unwrap().fields != Default::default(), "fields not set.");
+		ensure!(
+			registrars[r as usize].as_ref().unwrap().fields != Default::default(),
+			"fields not set."
+		);
+
+		Ok(())
 	}
 
-	provide_judgement {
+	#[benchmark]
+	fn provide_judgement(
+		r: Linear<2, MAX_REGISTRARS>,
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+	) -> Result<(), BenchmarkError> {
+		let r = r - 1;
 		// The user
 		let user: T::AccountId = account("user", r, SEED);
-		let user_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(user.clone()));
+		let user_origin =
+			<T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(user.clone()));
 		let user_lookup = <T::Lookup as StaticLookup>::unlookup(user.clone());
 		let _ = T::Currency::make_free_balance_be(&user, BalanceOf::<T>::max_value());
 
@@ -368,8 +503,7 @@
 		let caller_lookup = T::Lookup::unlookup(caller.clone());
 		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
 
-		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
-		let x in 0 .. T::MaxAdditionalFields::get();
+		add_registrars::<T>(r)?;
 
 		let info = create_identity_info::<T>(x);
 		let info_hash = T::Hashing::hash_of(&info);
@@ -378,18 +512,38 @@
 		let registrar_origin = T::RegistrarOrigin::try_successful_origin().unwrap();
 		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
 		Identity::<T>::request_judgement(user_origin, r, 10u32.into())?;
-	}: _(RawOrigin::Signed(caller), r, user_lookup, Judgement::Reasonable, info_hash)
-	verify {
-		assert_last_event::<T>(Event::<T>::JudgementGiven { target: user, registrar_index: r }.into())
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller),
+			r,
+			user_lookup,
+			Judgement::Reasonable,
+			info_hash,
+		);
+
+		assert_last_event::<T>(
+			Event::<T>::JudgementGiven {
+				target: user,
+				registrar_index: r,
+			}
+			.into(),
+		);
+
+		Ok(())
 	}
 
-	kill_identity {
-		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
-		let s in 0 .. T::MaxSubAccounts::get();
-		let x in 0 .. T::MaxAdditionalFields::get();
+	#[benchmark]
+	fn kill_identity(
+		r: Linear<1, MAX_REGISTRARS>,
+		s: Linear<0, MAX_SUB_ACCOUNTS>,
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+	) -> Result<(), BenchmarkError> {
+		add_registrars::<T>(r)?;
 
 		let target: T::AccountId = account("target", 0, SEED);
-		let target_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(target.clone()).into();
+		let target_origin: <T as frame_system::Config>::RuntimeOrigin =
+			RawOrigin::Signed(target.clone()).into();
 		let target_lookup = T::Lookup::unlookup(target.clone());
 		let _ = T::Currency::make_free_balance_be(&target, BalanceOf::<T>::max_value());
 
@@ -400,7 +554,7 @@
 		// User requests judgement from all the registrars, and they approve
 		for i in 0..r {
 			let registrar: T::AccountId = account("registrar", i, SEED);
-			let balance_to_use =  balance_unit::<T>() * 10u32.into();
+			let balance_to_use = balance_unit::<T>() * 10u32.into();
 			let _ = T::Currency::make_free_balance_be(&registrar, balance_to_use);
 
 			Identity::<T>::request_judgement(target_origin.clone(), i, 10u32.into())?;
@@ -414,110 +568,190 @@
 		}
 		ensure!(IdentityOf::<T>::contains_key(&target), "Identity not set");
 		let origin = T::ForceOrigin::try_successful_origin().unwrap();
-	}: _<T::RuntimeOrigin>(origin, target_lookup)
-	verify {
-		ensure!(!IdentityOf::<T>::contains_key(&target), "Identity not removed");
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, target_lookup);
+
+		ensure!(
+			!IdentityOf::<T>::contains_key(&target),
+			"Identity not removed"
+		);
+
+		Ok(())
 	}
 
-	force_insert_identities {
-		let x in 0 .. T::MaxAdditionalFields::get();
-		let n in 0..600;
+	#[benchmark]
+	fn force_insert_identities(
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+		n: Linear<0, 600>,
+	) -> Result<(), BenchmarkError> {
 		use frame_benchmarking::account;
-		let identities = (0..n).map(|i| (
-			account("caller", i, SEED),
-			Registration::<BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields> {
-				judgements: Default::default(),
-				deposit: Default::default(),
-				info: create_identity_info::<T>(x),
-			},
-		)).collect::<Vec<_>>();
+		let identities = (0..n)
+			.map(|i| {
+				(
+					account("caller", i, SEED),
+					Registration::<BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields> {
+						judgements: Default::default(),
+						deposit: Default::default(),
+						info: create_identity_info::<T>(x),
+					},
+				)
+			})
+			.collect::<Vec<_>>();
 		let origin = T::ForceOrigin::try_successful_origin().unwrap();
-	}: _<T::RuntimeOrigin>(origin, identities)
 
-	force_remove_identities {
-		let x in 0 .. T::MaxAdditionalFields::get();
-		let n in 0..600;
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, identities);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn force_remove_identities(
+		x: Linear<0, MAX_ADDITIONAL_FIELDS>,
+		n: Linear<0, 600>,
+	) -> Result<(), BenchmarkError> {
 		use frame_benchmarking::account;
 		let origin = T::ForceOrigin::try_successful_origin().unwrap();
-		let identities = (0..n).map(|i| (
-			account("caller", i, SEED),
-			Registration::<BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields> {
-				judgements: Default::default(),
-				deposit: Default::default(),
-				info: create_identity_info::<T>(x),
-			},
-		)).collect::<Vec<_>>();
-		assert_ok!(
-			Identity::<T>::force_insert_identities(origin.clone(), identities.clone()),
-		);
-		let identities = identities.into_iter().map(|(acc, _)| acc).collect::<Vec<_>>();
-	}: _<T::RuntimeOrigin>(origin, identities)
+		let identities = (0..n)
+			.map(|i| {
+				(
+					account("caller", i, SEED),
+					Registration::<BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields> {
+						judgements: Default::default(),
+						deposit: Default::default(),
+						info: create_identity_info::<T>(x),
+					},
+				)
+			})
+			.collect::<Vec<_>>();
+		assert_ok!(Identity::<T>::force_insert_identities(
+			origin.clone(),
+			identities.clone()
+		),);
+		let identities = identities
+			.into_iter()
+			.map(|(acc, _)| acc)
+			.collect::<Vec<_>>();
 
-	force_set_subs {
-		let s in 0 .. T::MaxSubAccounts::get();
-		let n in 0..600;
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, identities);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn force_set_subs(
+		s: Linear<0, MAX_SUB_ACCOUNTS>,
+		n: Linear<0, 600>,
+	) -> Result<(), BenchmarkError> {
 		use frame_benchmarking::account;
-		let identities = (0..n).map(|i| {
-			let caller: T::AccountId = account("caller", i, SEED);
-			(
-				caller.clone(),
+		let identities = (0..n)
+			.map(|i| {
+				let caller: T::AccountId = account("caller", i, SEED);
 				(
-					BalanceOf::<T>::max_value(),
-					create_sub_accounts::<T>(&caller, s).unwrap().try_into().unwrap(),
-				),
-			)
-		}).collect::<Vec<_>>();
+					caller.clone(),
+					(
+						BalanceOf::<T>::max_value(),
+						create_sub_accounts::<T>(&caller, s)
+							.unwrap()
+							.try_into()
+							.unwrap(),
+					),
+				)
+			})
+			.collect::<Vec<_>>();
 		let origin = T::ForceOrigin::try_successful_origin().unwrap();
-	}: _<T::RuntimeOrigin>(origin, identities)
 
-	add_sub {
-		let s in 0 .. T::MaxSubAccounts::get() - 1;
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, identities);
 
+		Ok(())
+	}
+
+	#[benchmark]
+	fn add_sub(s: Linear<1, MAX_SUB_ACCOUNTS>) -> Result<(), BenchmarkError> {
+		let s = s - 1;
 		let caller: T::AccountId = whitelisted_caller();
 		let _ = add_sub_accounts::<T>(&caller, s)?;
 		let sub = account("new_sub", 0, SEED);
 		let data = Data::Raw(vec![0; 32].try_into().unwrap());
-		ensure!(SubsOf::<T>::get(&caller).1.len() as u32 == s, "Subs not set.");
-	}: _(RawOrigin::Signed(caller.clone()), T::Lookup::unlookup(sub), data)
-	verify {
-		ensure!(SubsOf::<T>::get(&caller).1.len() as u32 == s + 1, "Subs not added.");
-	}
+		ensure!(
+			SubsOf::<T>::get(&caller).1.len() as u32 == s,
+			"Subs not set."
+		);
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			T::Lookup::unlookup(sub),
+			data,
+		);
+
+		ensure!(
+			SubsOf::<T>::get(&caller).1.len() as u32 == s + 1,
+			"Subs not added."
+		);
 
-	rename_sub {
-		let s in 1 .. T::MaxSubAccounts::get();
+		Ok(())
+	}
 
+	#[benchmark]
+	fn rename_sub(s: Linear<1, MAX_SUB_ACCOUNTS>) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
 		let (sub, _) = add_sub_accounts::<T>(&caller, s)?.remove(0);
 		let data = Data::Raw(vec![1; 32].try_into().unwrap());
-		ensure!(SuperOf::<T>::get(&sub).unwrap().1 != data, "data already set");
-	}: _(RawOrigin::Signed(caller), T::Lookup::unlookup(sub.clone()), data.clone())
-	verify {
+		ensure!(
+			SuperOf::<T>::get(&sub).unwrap().1 != data,
+			"data already set"
+		);
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller),
+			T::Lookup::unlookup(sub.clone()),
+			data.clone(),
+		);
+
 		ensure!(SuperOf::<T>::get(&sub).unwrap().1 == data, "data not set");
-	}
 
-	remove_sub {
-		let s in 1 .. T::MaxSubAccounts::get();
+		Ok(())
+	}
 
+	#[benchmark]
+	fn remove_sub(s: Linear<1, MAX_SUB_ACCOUNTS>) -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = whitelisted_caller();
 		let (sub, _) = add_sub_accounts::<T>(&caller, s)?.remove(0);
 		ensure!(SuperOf::<T>::contains_key(&sub), "Sub doesn't exists");
-	}: _(RawOrigin::Signed(caller), T::Lookup::unlookup(sub.clone()))
-	verify {
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), T::Lookup::unlookup(sub.clone()));
+
 		ensure!(!SuperOf::<T>::contains_key(&sub), "Sub not removed");
+
+		Ok(())
 	}
 
-	quit_sub {
-		let s in 0 .. T::MaxSubAccounts::get() - 1;
-
+	#[benchmark]
+	fn quit_sub(s: Linear<1, MAX_SUB_ACCOUNTS>) -> Result<(), BenchmarkError> {
+		let s = s - 1;
 		let caller: T::AccountId = whitelisted_caller();
 		let sup = account("super", 0, SEED);
 		let _ = add_sub_accounts::<T>(&sup, s)?;
 		let sup_origin = RawOrigin::Signed(sup).into();
-		Identity::<T>::add_sub(sup_origin, T::Lookup::unlookup(caller.clone()), Data::Raw(vec![0; 32].try_into().unwrap()))?;
+		Identity::<T>::add_sub(
+			sup_origin,
+			T::Lookup::unlookup(caller.clone()),
+			Data::Raw(vec![0; 32].try_into().unwrap()),
+		)?;
 		ensure!(SuperOf::<T>::contains_key(&caller), "Sub doesn't exists");
-	}: _(RawOrigin::Signed(caller.clone()))
-	verify {
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
 		ensure!(!SuperOf::<T>::contains_key(&caller), "Sub not removed");
+
+		Ok(())
 	}
 
 	impl_benchmark_test_suite!(Identity, crate::tests::new_test_ext(), crate::tests::Test);