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/collator-selection/src/benchmarking.rs
+++ b/pallets/collator-selection/src/benchmarking.rs
@@ -32,7 +32,9 @@
 
 //! Benchmarking setup for pallet-collator-selection
 
-use frame_benchmarking::{account, benchmarks, impl_benchmark_test_suite, whitelisted_caller};
+use frame_benchmarking::v2::{
+	account, benchmarks, impl_benchmark_test_suite, whitelisted_caller, BenchmarkError,
+};
 use frame_support::{
 	assert_ok,
 	traits::{
@@ -159,16 +161,17 @@
 /// Our benchmarking environment already has invulnerables registered.
 const INITIAL_INVULNERABLES: u32 = 2;
 
-benchmarks! {
-	where_clause { where
-		T: Config + pallet_authorship::Config + session::Config
-	}
+#[benchmarks(where T: Config + pallet_authorship::Config + session::Config)]
+mod benchmarks {
+	use super::*;
+	const MAX_COLLATORS: u32 = 10;
+	const MAX_INVULNERABLES: u32 = MAX_COLLATORS - INITIAL_INVULNERABLES;
 
 	// todo:collator this and all the following do not work for some reason, going all the way up to 10 in length
 	// Both invulnerables and candidates count together against MaxCollators.
 	// Maybe try putting it in braces? 1 .. (T::MaxCollators::get() - 2)
-	add_invulnerable {
-		let b in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES - 1;
+	#[benchmark]
+	fn add_invulnerable<T>(b: Linear<1, MAX_COLLATORS>) -> Result<(), BenchmarkError> {
 		register_validators::<T>(b);
 		register_invulnerables::<T>(b);
 
@@ -181,39 +184,59 @@
 		<session::Pallet<T>>::set_keys(
 			RawOrigin::Signed(new_invulnerable.clone()).into(),
 			keys::<T>(b + 1),
-			Vec::new()
-		).unwrap();
+			Vec::new(),
+		)
+		.unwrap();
 
 		let root_origin = T::UpdateOrigin::try_successful_origin().unwrap();
-	}: {
-		assert_ok!(
-			<CollatorSelection<T>>::add_invulnerable(root_origin, new_invulnerable.clone())
+
+		#[block]
+		{
+			assert_ok!(<CollatorSelection<T>>::add_invulnerable(
+				root_origin,
+				new_invulnerable.clone()
+			));
+		}
+
+		assert_last_event::<T>(
+			Event::InvulnerableAdded {
+				invulnerable: new_invulnerable,
+			}
+			.into(),
 		);
-	}
-	verify {
-		assert_last_event::<T>(Event::InvulnerableAdded{invulnerable: new_invulnerable}.into());
+
+		Ok(())
 	}
 
-	remove_invulnerable {
-		let b in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES - 1;
+	#[benchmark]
+	fn remove_invulnerable(b: Linear<1, MAX_INVULNERABLES>) -> Result<(), BenchmarkError> {
 		register_validators::<T>(b);
 		register_invulnerables::<T>(b);
 
 		let root_origin = T::UpdateOrigin::try_successful_origin().unwrap();
 		let leaving = <Invulnerables<T>>::get().last().unwrap().clone();
 		whitelist!(leaving);
-	}: {
-		assert_ok!(
-			<CollatorSelection<T>>::remove_invulnerable(root_origin, leaving.clone())
+
+		#[block]
+		{
+			assert_ok!(<CollatorSelection<T>>::remove_invulnerable(
+				root_origin,
+				leaving.clone()
+			));
+		}
+
+		assert_last_event::<T>(
+			Event::InvulnerableRemoved {
+				invulnerable: leaving,
+			}
+			.into(),
 		);
-	}
-	verify {
-		assert_last_event::<T>(Event::InvulnerableRemoved{invulnerable: leaving}.into());
-	}
 
-	get_license {
-		let c in 1 .. T::MaxCollators::get() - 1;
+		Ok(())
+	}
 
+	#[benchmark]
+	fn get_license(c: Linear<1, MAX_COLLATORS>) -> Result<(), BenchmarkError> {
 		register_validators::<T>(c);
 		get_licenses::<T>(c);
 
@@ -224,19 +247,28 @@
 		<session::Pallet<T>>::set_keys(
 			RawOrigin::Signed(caller.clone()).into(),
 			keys::<T>(c + 1),
-			Vec::new()
-		).unwrap();
+			Vec::new(),
+		)
+		.unwrap();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert_last_event::<T>(
+			Event::LicenseObtained {
+				account_id: caller,
+				deposit: bond / 2u32.into(),
+			}
+			.into(),
+		);
 
-	}: _(RawOrigin::Signed(caller.clone()))
-	verify {
-		assert_last_event::<T>(Event::LicenseObtained{account_id: caller, deposit: bond / 2u32.into()}.into());
+		Ok(())
 	}
 
 	// worst case is when we have all the max-candidate slots filled except one, and we fill that
 	// one.
-	onboard {
-		let c in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES - 1;
-
+	#[benchmark]
+	fn onboard(c: Linear<1, MAX_INVULNERABLES>) -> Result<(), BenchmarkError> {
 		register_validators::<T>(c);
 		register_candidates::<T>(c);
 
@@ -246,37 +278,47 @@
 
 		let origin = RawOrigin::Signed(caller.clone());
 
-		<session::Pallet<T>>::set_keys(
-			origin.clone().into(),
-			keys::<T>(c + 1),
-			Vec::new()
-		).unwrap();
+		<session::Pallet<T>>::set_keys(origin.clone().into(), keys::<T>(c + 1), Vec::new())
+			.unwrap();
+
+		assert_ok!(<CollatorSelection<T>>::get_license(origin.clone().into()));
+
+		#[extrinsic_call]
+		_(origin);
+
+		assert_last_event::<T>(Event::CandidateAdded { account_id: caller }.into());
 
-		assert_ok!(
-			<CollatorSelection<T>>::get_license(origin.clone().into())
-		);
-	}: _(origin)
-	verify {
-		assert_last_event::<T>(Event::CandidateAdded{account_id: caller}.into());
+		Ok(())
 	}
 
 	// worst case is the last candidate leaving.
-	offboard {
-		let c in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES;
+	#[benchmark]
+	fn offboard(c: Linear<0, MAX_INVULNERABLES>) -> Result<(), BenchmarkError> {
+		let c = c + 1;
 
 		register_validators::<T>(c);
 		register_candidates::<T>(c);
 
 		let leaving = <Candidates<T>>::get().last().unwrap().clone();
 		whitelist!(leaving);
-	}: _(RawOrigin::Signed(leaving.clone()))
-	verify {
-		assert_last_event::<T>(Event::CandidateRemoved{account_id: leaving}.into());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(leaving.clone()));
+
+		assert_last_event::<T>(
+			Event::CandidateRemoved {
+				account_id: leaving,
+			}
+			.into(),
+		);
+
+		Ok(())
 	}
 
 	// worst case is the last candidate leaving.
-	release_license {
-		let c in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES;
+	#[benchmark]
+	fn release_license(c: Linear<0, MAX_INVULNERABLES>) -> Result<(), BenchmarkError> {
+		let c = c + 1;
 		let bond = balance_unit::<T>();
 
 		register_validators::<T>(c);
@@ -284,14 +326,25 @@
 
 		let leaving = <Candidates<T>>::get().last().unwrap().clone();
 		whitelist!(leaving);
-	}: _(RawOrigin::Signed(leaving.clone()))
-	verify {
-		assert_last_event::<T>(Event::LicenseReleased{account_id: leaving, deposit_returned: bond}.into());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(leaving.clone()));
+
+		assert_last_event::<T>(
+			Event::LicenseReleased {
+				account_id: leaving,
+				deposit_returned: bond,
+			}
+			.into(),
+		);
+
+		Ok(())
 	}
 
 	// worst case is the last candidate leaving.
-	force_release_license {
-		let c in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES;
+	#[benchmark]
+	fn force_release_license(c: Linear<0, MAX_INVULNERABLES>) -> Result<(), BenchmarkError> {
+		let c = c + 1;
 		let bond = balance_unit::<T>();
 
 		register_validators::<T>(c);
@@ -300,44 +353,65 @@
 		let leaving = <Candidates<T>>::get().last().unwrap().clone();
 		whitelist!(leaving);
 		let origin = T::UpdateOrigin::try_successful_origin().unwrap();
-	}: {
-		assert_ok!(
-			<CollatorSelection<T>>::force_release_license(origin, leaving.clone())
+
+		#[block]
+		{
+			assert_ok!(<CollatorSelection<T>>::force_release_license(
+				origin,
+				leaving.clone()
+			));
+		}
+
+		assert_last_event::<T>(
+			Event::LicenseReleased {
+				account_id: leaving,
+				deposit_returned: bond,
+			}
+			.into(),
 		);
-	}
-	verify {
-		assert_last_event::<T>(Event::LicenseReleased{account_id: leaving, deposit_returned: bond}.into());
+
+		Ok(())
 	}
 
 	// worst case is paying a non-existing candidate account.
-	note_author {
+	#[benchmark]
+	fn note_author() -> Result<(), BenchmarkError> {
 		T::Currency::set_balance(
 			&<CollatorSelection<T>>::account_id(),
 			balance_unit::<T>() * 4u32.into(),
 		);
 		let author = account("author", 0, SEED);
-		let new_block: BlockNumberFor<T>= 10u32.into();
+		let new_block: BlockNumberFor<T> = 10u32.into();
 
 		frame_system::Pallet::<T>::set_block_number(new_block);
 		assert!(T::Currency::balance(&author) == 0u32.into());
-	}: {
-		<CollatorSelection<T> as EventHandler<_, _>>::note_author(author.clone())
-	} verify {
+
+		#[block]
+		{
+			<CollatorSelection<T> as EventHandler<_, _>>::note_author(author.clone());
+		}
+
 		assert!(T::Currency::balance(&author) > 0u32.into());
 		assert_eq!(frame_system::Pallet::<T>::block_number(), new_block);
+
+		Ok(())
 	}
 
 	// worst case for new session.
-	new_session {
-		let r in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES;
-		let c in 1 .. T::MaxCollators::get() - INITIAL_INVULNERABLES;
+	#[benchmark]
+	fn new_session(
+		r: Linear<0, MAX_INVULNERABLES>,
+		c: Linear<0, MAX_INVULNERABLES>,
+	) -> Result<(), BenchmarkError> {
+		let r = r + 1;
+		let c = c + 1;
 
 		frame_system::Pallet::<T>::set_block_number(0u32.into());
 
 		register_validators::<T>(c);
 		register_candidates::<T>(c);
 
-		let new_block: BlockNumberFor<T>= 1800u32.into();
+		let new_block: BlockNumberFor<T> = 1800u32.into();
 		let zero_block: BlockNumberFor<T> = 0u32.into();
 		let candidates = <Candidates<T>>::get();
 
@@ -362,19 +436,24 @@
 		frame_system::Pallet::<T>::set_block_number(new_block);
 
 		assert!(<Candidates<T>>::get().len() == c as usize);
-	}: {
-		<CollatorSelection<T> as SessionManager<_>>::new_session(0)
-	} verify {
+
+		#[block]
+		{
+			<CollatorSelection<T> as SessionManager<_>>::new_session(0);
+		}
+
 		if c > r {
 			assert!(<Candidates<T>>::get().len() < pre_length);
 		} else {
 			assert!(<Candidates<T>>::get().len() == pre_length);
 		}
+
+		Ok(())
 	}
-}
 
-impl_benchmark_test_suite!(
-	CollatorSelection,
-	crate::mock::new_test_ext(),
-	crate::mock::Test,
-);
+	impl_benchmark_test_suite!(
+		CollatorSelection,
+		crate::mock::new_test_ext(),
+		crate::mock::Test,
+	);
+}

--- 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);

--- a/pallets/inflation/src/benchmarking.rs
+++ b/pallets/inflation/src/benchmarking.rs
@@ -16,18 +16,29 @@
 
 #![cfg(feature = "runtime-benchmarks")]
 
-use frame_benchmarking::benchmarks;
-use frame_support::{pallet_prelude::*, traits::Hooks};
+use frame_benchmarking::v2::*;
+use frame_support::traits::Hooks;
+use sp_std::vec;
 
 use super::*;
 use crate::Pallet as Inflation;
 
-benchmarks! {
+#[benchmarks]
+mod benchmarks {
+	use super::*;
 
-	on_initialize {
+	#[benchmark]
+	fn on_initialize() -> Result<(), BenchmarkError> {
 		let block1: BlockNumberFor<T> = 1u32.into();
 		let block2: BlockNumberFor<T> = 2u32.into();
 		<Inflation<T> as Hooks>::on_initialize(block1); // Create Treasury account
-	}: { <Inflation<T> as Hooks>::on_initialize(block2); } // Benchmark deposit_into_existing path
 
+		#[block]
+		{
+			<Inflation<T> as Hooks>::on_initialize(block2);
+			// Benchmark deposit_into_existing path
+		}
+
+		Ok(())
+	}
 }

--- a/pallets/maintenance/src/benchmarking.rs
+++ b/pallets/maintenance/src/benchmarking.rs
@@ -14,36 +14,60 @@
 // 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::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_support::{ensure, pallet_prelude::Weight, traits::StorePreimage};
 use frame_system::RawOrigin;
 use parity_scale_codec::Encode;
+use sp_std::vec;
 
 use super::*;
 use crate::{Config, Pallet as Maintenance};
 
-benchmarks! {
-	enable {
-	}: _(RawOrigin::Root)
-	verify {
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn enable() -> Result<(), BenchmarkError> {
+		#[extrinsic_call]
+		_(RawOrigin::Root);
+
 		ensure!(<Enabled<T>>::get(), "didn't enable the MM");
+
+		Ok(())
 	}
 
-	disable {
+	#[benchmark]
+	fn disable() -> Result<(), BenchmarkError> {
 		Maintenance::<T>::enable(RawOrigin::Root.into())?;
-	}: _(RawOrigin::Root)
-	verify {
+
+		#[extrinsic_call]
+		_(RawOrigin::Root);
+
 		ensure!(!<Enabled<T>>::get(), "didn't disable the MM");
+
+		Ok(())
 	}
 
-	#[pov_mode = MaxEncodedLen {
-		// PoV size is deducted from weight_bound
-		Preimage::PreimageFor: Measured
-	}]
-	execute_preimage {
-		let call = <T as Config>::RuntimeCall::from(frame_system::Call::<T>::remark { remark: 1u32.encode() });
+	// TODO: fix
+	// #[pov_mode = MaxEncodedLen {
+	// 	// PoV size is deducted from weight_bound
+	// 	Preimage::PreimageFor: Measured
+	// }]
+	#[benchmark]
+	fn execute_preimage() -> Result<(), BenchmarkError> {
+		let call = <T as Config>::RuntimeCall::from(frame_system::Call::<T>::remark {
+			remark: 1u32.encode(),
+		});
 		let hash = T::Preimages::note(call.encode().into())?;
-	}: _(RawOrigin::Root, hash, Weight::from_parts(100000000000, 100000000000))
-	verify {
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Root,
+			hash,
+			Weight::from_parts(100000000000, 100000000000),
+		);
+
+		Ok(())
 	}
 }

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use frame_benchmarking::{account, benchmarks};17use frame_benchmarking::v2::{account, benchmarks, BenchmarkError};
18use pallet_common::{18use pallet_common::{
19	bench_init,19	bench_init,
20	benchmarking::{20	benchmarking::{
64	)64	)
65}65}
6666
67benchmarks! {67#[benchmarks]
68mod benchmarks {
68	create_item {69	use super::*;
70
71	#[benchmark]
72	fn create_item() -> Result<(), BenchmarkError> {
69		bench_init!{73		bench_init! {
70			owner: sub; collection: collection(owner);74			owner: sub; collection: collection(owner);
71			sender: cross_from_sub(owner); to: cross_sub;75			sender: cross_from_sub(owner); to: cross_sub;
72		};76		};
73	}: {create_max_item(&collection, &sender, to.clone())?}
7477
75	create_multiple_items {78		#[block]
79		{
76		let b in 0..MAX_ITEMS_PER_BATCH;80			create_max_item(&collection, &sender, to.clone())?;
81		}
82
83		Ok(())
84	}
85
86	#[benchmark]
87	fn create_multiple_items(b: Linear<0, MAX_ITEMS_PER_BATCH>) -> Result<(), BenchmarkError> {
77		bench_init!{88		bench_init! {
78			owner: sub; collection: collection(owner);89			owner: sub; collection: collection(owner);
79			sender: cross_from_sub(owner); to: cross_sub;90			sender: cross_from_sub(owner); to: cross_sub;
80		};91		};
81		let data = (0..b).map(|_| create_max_item_data::<T>(to.clone())).collect();92		let data = (0..b)
82	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}93			.map(|_| create_max_item_data::<T>(to.clone()))
94			.collect();
8395
84	create_multiple_items_ex {96		#[block]
97		{
85		let b in 0..MAX_ITEMS_PER_BATCH;98			<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?;
99		}
100
101		Ok(())
102	}
103
104	#[benchmark]
105	fn create_multiple_items_ex(b: Linear<0, MAX_ITEMS_PER_BATCH>) -> Result<(), BenchmarkError> {
86		bench_init!{106		bench_init! {
87			owner: sub; collection: collection(owner);107			owner: sub; collection: collection(owner);
88			sender: cross_from_sub(owner);108			sender: cross_from_sub(owner);
89		};109		};
90		let data = (0..b).map(|i| {110		let data = (0..b)
111			.map(|i| {
91			bench_init!(to: cross_sub(i););112				bench_init!(to: cross_sub(i););
92			create_max_item_data::<T>(to)113				create_max_item_data::<T>(to)
93		}).collect();114			})
94	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}115			.collect();
95116
96	burn_item {117		#[block]
118		{
119			<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?;
120		}
121
122		Ok(())
123	}
124
125	#[benchmark]
126	fn burn_item() -> Result<(), BenchmarkError> {
97		bench_init!{127		bench_init! {
98			owner: sub; collection: collection(owner);128			owner: sub; collection: collection(owner);
99			sender: cross_from_sub(owner); burner: cross_sub;129			sender: cross_from_sub(owner); burner: cross_sub;
100		};130		};
101		let item = create_max_item(&collection, &sender, burner.clone())?;131		let item = create_max_item(&collection, &sender, burner.clone())?;
102	}: {<Pallet<T>>::burn(&collection, &burner, item)?}
103132
104	burn_recursively_self_raw {133		#[block]
134		{
135			<Pallet<T>>::burn(&collection, &burner, item)?;
136		}
137
138		Ok(())
139	}
140
141	#[benchmark]
142	fn burn_recursively_self_raw() -> Result<(), BenchmarkError> {
105		bench_init!{143		bench_init! {
106			owner: sub; collection: collection(owner);144			owner: sub; collection: collection(owner);
107			sender: cross_from_sub(owner); burner: cross_sub;145			sender: cross_from_sub(owner); burner: cross_sub;
108		};146		};
109		let item = create_max_item(&collection, &sender, burner.clone())?;147		let item = create_max_item(&collection, &sender, burner.clone())?;
110	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
111148
112	burn_recursively_breadth_plus_self_plus_self_per_each_raw {149		#[block]
150		{
113		let b in 0..200;151			<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
152		}
153
154		Ok(())
155	}
156
157	#[benchmark]
158	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(
159		b: Linear<0, 200>,
114		bench_init!{160	) -> Result<(), BenchmarkError> {
161		bench_init! {
115			owner: sub; collection: collection(owner);162			owner: sub; collection: collection(owner);
116			sender: cross_from_sub(owner); burner: cross_sub;163			sender: cross_from_sub(owner); burner: cross_sub;
117		};164		};
118		let item = create_max_item(&collection, &sender, burner.clone())?;165		let item = create_max_item(&collection, &sender, burner.clone())?;
119		for i in 0..b {166		for _ in 0..b {
120			create_max_item(&collection, &sender, T::CrossTokenAddressMapping::token_to_address(collection.id, item))?;167			create_max_item(
168				&collection,
169				&sender,
170				T::CrossTokenAddressMapping::token_to_address(collection.id, item),
171			)?;
121		}172		}
122	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
123173
124	transfer_raw {174		#[block]
175		{
176			<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
177		}
178
179		Ok(())
180	}
181
182	#[benchmark]
183	fn transfer_raw() -> Result<(), BenchmarkError> {
125		bench_init!{184		bench_init! {
126			owner: sub; collection: collection(owner);185			owner: sub; collection: collection(owner);
127			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;186			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;
128		};187		};
129		let item = create_max_item(&collection, &owner, sender.clone())?;188		let item = create_max_item(&collection, &owner, sender.clone())?;
130	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, &Unlimited)?}
131189
132	approve {190		#[block]
191		{
192			<Pallet<T>>::transfer(&collection, &sender, &receiver, item, &Unlimited)?;
193		}
194
195		Ok(())
196	}
197
198	#[benchmark]
199	fn approve() -> Result<(), BenchmarkError> {
133		bench_init!{200		bench_init! {
134			owner: sub; collection: collection(owner);201			owner: sub; collection: collection(owner);
135			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;202			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
136		};203		};
137		let item = create_max_item(&collection, &owner, sender.clone())?;204		let item = create_max_item(&collection, &owner, sender.clone())?;
138	}: {<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?}
139205
140	approve_from {206		#[block]
207		{
208			<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;
209		}
210
211		Ok(())
212	}
213
214	#[benchmark]
215	fn approve_from() -> Result<(), BenchmarkError> {
141		bench_init!{216		bench_init! {
142			owner: sub; collection: collection(owner);217			owner: sub; collection: collection(owner);
143			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;218			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
144		};219		};
145		let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth());220		let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth());
146		let item = create_max_item(&collection, &owner, owner_eth.clone())?;221		let item = create_max_item(&collection, &owner, owner_eth.clone())?;
147	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, item, Some(&spender))?}
148222
149	check_allowed_raw {223		#[block]
224		{
225			<Pallet<T>>::set_allowance_from(
226				&collection,
227				&sender,
228				&owner_eth,
229				item,
230				Some(&spender),
231			)?;
232		}
233
234		Ok(())
235	}
236
237	#[benchmark]
238	fn check_allowed_raw() -> Result<(), BenchmarkError> {
150		bench_init!{239		bench_init! {
151			owner: sub; collection: collection(owner);240			owner: sub; collection: collection(owner);
152			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;241			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
153		};242		};
154		let item = create_max_item(&collection, &owner, sender.clone())?;243		let item = create_max_item(&collection, &owner, sender.clone())?;
155		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;244		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;
156	}: {<Pallet<T>>::check_allowed(&collection, &spender, &sender, item, &Unlimited)?}
157245
158	burn_from {246		#[block]
247		{
248			<Pallet<T>>::check_allowed(&collection, &spender, &sender, item, &Unlimited)?;
249		}
250
251		Ok(())
252	}
253
254	#[benchmark]
255	fn burn_from() -> Result<(), BenchmarkError> {
159		bench_init!{256		bench_init! {
160			owner: sub; collection: collection(owner);257			owner: sub; collection: collection(owner);
161			owner: cross_from_sub; sender: cross_sub; burner: cross_sub;258			owner: cross_from_sub; sender: cross_sub; burner: cross_sub;
162		};259		};
163		let item = create_max_item(&collection, &owner, sender.clone())?;260		let item = create_max_item(&collection, &owner, sender.clone())?;
164		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;261		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;
165	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?}
166262
167	set_token_property_permissions {263		#[block]
264		{
168		let b in 0..MAX_PROPERTIES_PER_ITEM;265			<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?;
266		}
267
268		Ok(())
269	}
270
271	#[benchmark]
272	fn set_token_property_permissions(
273		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
169		bench_init!{274	) -> Result<(), BenchmarkError> {
275		bench_init! {
170			owner: sub; collection: collection(owner);276			owner: sub; collection: collection(owner);
171			owner: cross_from_sub;277			owner: cross_from_sub;
172		};278		};
173		let perms = (0..b).map(|k| PropertyKeyPermission {279		let perms = (0..b)
280			.map(|k| PropertyKeyPermission {
174			key: property_key(k as usize),281				key: property_key(k as usize),
175			permission: PropertyPermission {282				permission: PropertyPermission {
176				mutable: false,283					mutable: false,
177				collection_admin: false,284					collection_admin: false,
178				token_owner: false,285					token_owner: false,
179			},286				},
180		}).collect::<Vec<_>>();287			})
181	}: {<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?}288			.collect::<Vec<_>>();
182289
183	set_token_properties {290		#[block]
291		{
184		let b in 0..MAX_PROPERTIES_PER_ITEM;292			<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
293		}
294
295		Ok(())
296	}
297
298	#[benchmark]
299	fn set_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
185		bench_init!{300		bench_init! {
186			owner: sub; collection: collection(owner);301			owner: sub; collection: collection(owner);
187			owner: cross_from_sub;302			owner: cross_from_sub;
188		};303		};
189		let perms = (0..b).map(|k| PropertyKeyPermission {304		let perms = (0..b)
305			.map(|k| PropertyKeyPermission {
190			key: property_key(k as usize),306				key: property_key(k as usize),
191			permission: PropertyPermission {307				permission: PropertyPermission {
192				mutable: false,308					mutable: false,
193				collection_admin: true,309					collection_admin: true,
194				token_owner: true,310					token_owner: true,
195			},311				},
196		}).collect::<Vec<_>>();312			})
313			.collect::<Vec<_>>();
197		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;314		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
198		let props = (0..b).map(|k| Property {315		let props = (0..b)
316			.map(|k| Property {
199			key: property_key(k as usize),317				key: property_key(k as usize),
200			value: property_value(),318				value: property_value(),
201		}).collect::<Vec<_>>();319			})
320			.collect::<Vec<_>>();
202		let item = create_max_item(&collection, &owner, owner.clone())?;321		let item = create_max_item(&collection, &owner, owner.clone())?;
203	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), &Unlimited)?}
204322
205	init_token_properties {323		#[block]
324		{
206		let b in 0..MAX_PROPERTIES_PER_ITEM;325			<Pallet<T>>::set_token_properties(
326				&collection,
327				&owner,
328				item,
329				props.into_iter(),
330				&Unlimited,
331			)?;
332		}
333
334		Ok(())
335	}
336
337	#[benchmark]
338	fn init_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
207		bench_init!{339		bench_init! {
208			owner: sub; collection: collection(owner);340			owner: sub; collection: collection(owner);
209			owner: cross_from_sub;341			owner: cross_from_sub;
210		};342		};
211343
212		let perms = (0..b).map(|k| PropertyKeyPermission {344		let perms = (0..b)
345			.map(|k| PropertyKeyPermission {
213			key: property_key(k as usize),346				key: property_key(k as usize),
214			permission: PropertyPermission {347				permission: PropertyPermission {
215				mutable: false,348					mutable: false,
216				collection_admin: true,349					collection_admin: true,
217				token_owner: true,350					token_owner: true,
218			},351				},
219		}).collect::<Vec<_>>();352			})
353			.collect::<Vec<_>>();
220		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;354		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
221		let props = (0..b).map(|k| Property {355		let props = (0..b)
356			.map(|k| Property {
222			key: property_key(k as usize),357				key: property_key(k as usize),
223			value: property_value(),358				value: property_value(),
224		}).collect::<Vec<_>>();359			})
360			.collect::<Vec<_>>();
225		let item = create_max_item(&collection, &owner, owner.clone())?;361		let item = create_max_item(&collection, &owner, owner.clone())?;
226362
227		let (is_collection_admin, property_permissions) = load_is_admin_and_property_permissions(&collection, &owner);363		let (is_collection_admin, property_permissions) =
364			load_is_admin_and_property_permissions(&collection, &owner);
228	}: {365		todo!();
366		#[block]
367		{}
229		let mut property_writer = pallet_common::collection_info_loaded_property_writer(368		// let mut property_writer = pallet_common::collection_info_loaded_property_writer(
230			&collection,369		// 	&collection,
231			is_collection_admin,370		// 	is_collection_admin,
232			property_permissions,371		// 	property_permissions,
233		);372		// );
234373
235		property_writer.write_token_properties(374		// #[block]
375		// {
376		// 	property_writer.write_token_properties(
236			true,377		// 		true,
237			item,378		// 		item,
238			props.into_iter(),379		// 		props.into_iter(),
239			crate::erc::ERC721TokenEvent::TokenChanged {380		// 		crate::erc::ERC721TokenEvent::TokenChanged {
240				token_id: item.into(),381		// 			token_id: item.into(),
241			}382		// 		}
242			.to_log(T::ContractAddress::get()),383		// 		.to_log(T::ContractAddress::get()),
243		)?384		// 	)?;
385		// }
386
387		Ok(())
244	}388	}
245389
246	delete_token_properties {390	#[benchmark]
391	fn delete_token_properties(
247		let b in 0..MAX_PROPERTIES_PER_ITEM;392		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
248		bench_init!{393	) -> Result<(), BenchmarkError> {
394		bench_init! {
249			owner: sub; collection: collection(owner);395			owner: sub; collection: collection(owner);
250			owner: cross_from_sub;396			owner: cross_from_sub;
251		};397		};
252		let perms = (0..b).map(|k| PropertyKeyPermission {398		let perms = (0..b)
399			.map(|k| PropertyKeyPermission {
253			key: property_key(k as usize),400				key: property_key(k as usize),
254			permission: PropertyPermission {401				permission: PropertyPermission {
255				mutable: true,402					mutable: true,
256				collection_admin: true,403					collection_admin: true,
257				token_owner: true,404					token_owner: true,
258			},405				},
259		}).collect::<Vec<_>>();406			})
407			.collect::<Vec<_>>();
260		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;408		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
261		let props = (0..b).map(|k| Property {409		let props = (0..b)
410			.map(|k| Property {
262			key: property_key(k as usize),411				key: property_key(k as usize),
263			value: property_value(),412				value: property_value(),
264		}).collect::<Vec<_>>();413			})
414			.collect::<Vec<_>>();
265		let item = create_max_item(&collection, &owner, owner.clone())?;415		let item = create_max_item(&collection, &owner, owner.clone())?;
266		<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), &Unlimited)?;416		<Pallet<T>>::set_token_properties(
417			&collection,
418			&owner,
419			item,
420			props.into_iter(),
421			&Unlimited,
422		)?;
267		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();423		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
268	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?}
269424
270	token_owner {425		#[block]
426		{
427			<Pallet<T>>::delete_token_properties(
428				&collection,
429				&owner,
430				item,
431				to_delete.into_iter(),
432				&Unlimited,
433			)?;
434		}
435
436		Ok(())
437	}
438
439	#[benchmark]
440	fn token_owner() -> Result<(), BenchmarkError> {
271		bench_init!{441		bench_init! {
272			owner: sub; collection: collection(owner);442			owner: sub; collection: collection(owner);
273			owner: cross_from_sub;443			owner: cross_from_sub;
274		};444		};
275		let item = create_max_item(&collection, &owner, owner.clone())?;445		let item = create_max_item(&collection, &owner, owner.clone())?;
276	}: {collection.token_owner(item).unwrap()}
277446
278	set_allowance_for_all {447		#[block]
448		{
449			collection.token_owner(item).unwrap();
450		}
451
452		Ok(())
453	}
454
455	#[benchmark]
456	fn set_allowance_for_all() -> Result<(), BenchmarkError> {
279		bench_init!{457		bench_init! {
280			owner: sub; collection: collection(owner); owner: cross_from_sub;458			owner: sub; collection: collection(owner); owner: cross_from_sub;
281			operator: cross_sub;459			operator: cross_sub;
282		};460		};
283	}: {<Pallet<T>>::set_allowance_for_all(&collection, &owner, &operator, true)?}
284461
285	allowance_for_all {462		#[block]
463		{
464			<Pallet<T>>::set_allowance_for_all(&collection, &owner, &operator, true)?;
465		}
466
467		Ok(())
468	}
469
470	#[benchmark]
471	fn allowance_for_all() -> Result<(), BenchmarkError> {
286		bench_init!{472		bench_init! {
287			owner: sub; collection: collection(owner); owner: cross_from_sub;473			owner: sub; collection: collection(owner); owner: cross_from_sub;
288			operator: cross_sub;474			operator: cross_sub;
289		};475		};
290	}: {<Pallet<T>>::allowance_for_all(&collection, &owner, &operator)}
291476
292	repair_item {477		#[block]
478		{
479			<Pallet<T>>::allowance_for_all(&collection, &owner, &operator);
480		}
481
482		Ok(())
483	}
484
485	#[benchmark]
486	fn repair_item() -> Result<(), BenchmarkError> {
293		bench_init!{487		bench_init! {
294			owner: sub; collection: collection(owner);488			owner: sub; collection: collection(owner);
295			owner: cross_from_sub;489			owner: cross_from_sub;
296		};490		};
297		let item = create_max_item(&collection, &owner, owner.clone())?;491		let item = create_max_item(&collection, &owner, owner.clone())?;
492
298	}: {<Pallet<T>>::repair_item(&collection, item)?}493		#[block]
494		{
495			<Pallet<T>>::repair_item(&collection, item)?;
496		}
497
498		Ok(())
499	}
299}500}
300501

--- a/pallets/refungible/src/benchmarking.rs
+++ b/pallets/refungible/src/benchmarking.rs
@@ -16,11 +16,12 @@
 
 use core::{convert::TryInto, iter::IntoIterator};
 
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::v2::*;
 use pallet_common::{
 	bench_init,
 	benchmarking::{
-		create_collection_raw, load_is_admin_and_property_permissions, property_key, property_value,
+		create_collection_raw, /*load_is_admin_and_property_permissions,*/ property_key,
+		property_value,
 	},
 };
 use sp_std::prelude::*;
@@ -68,38 +69,70 @@
 	)
 }
 
-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;
 		};
-	}: {create_max_item(&collection, &sender, [(to.clone(), 200)])?}
 
-	create_multiple_items {
-		let b in 0..MAX_ITEMS_PER_BATCH;
-		bench_init!{
+		#[block]
+		{
+			create_max_item(&collection, &sender, [(to.clone(), 200)])?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn create_multiple_items(b: Linear<0, MAX_ITEMS_PER_BATCH>) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); to: cross_sub;
 		};
-		let data = (0..b).map(|_| create_max_item_data::<T>([(to.clone(), 200)])).collect();
-	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
+		let data = (0..b)
+			.map(|_| create_max_item_data::<T>([(to.clone(), 200)]))
+			.collect();
 
-	create_multiple_items_ex_multiple_items {
-		let b in 0..MAX_ITEMS_PER_BATCH;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+	#[benchmark]
+	fn create_multiple_items_ex_multiple_items(
+		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(|t| {
-			bench_init!(to: cross_sub(t););
-			create_max_item_data::<T>([(to, 200)])
-		}).collect();
-	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
+		let data = (0..b)
+			.map(|t| {
+				bench_init!(to: cross_sub(t););
+				create_max_item_data::<T>([(to, 200)])
+			})
+			.collect();
+
+		#[block]
+		{
+			<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?;
+		}
 
-	create_multiple_items_ex_multiple_owners {
-		let b in 0..MAX_ITEMS_PER_BATCH;
-		bench_init!{
+		Ok(())
+	}
+
+	#[benchmark]
+	fn create_multiple_items_ex_multiple_owners(
+		b: Linear<0, MAX_ITEMS_PER_BATCH>,
+	) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner);
 		};
@@ -107,258 +140,531 @@
 			bench_init!(to: cross_sub(u););
 			(to, 200)
 		}))];
-	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
 
+		#[block]
+		{
+			<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
 	// Other user left, token data is kept
-	burn_item_partial {
-		bench_init!{
+	#[benchmark]
+	fn burn_item_partial() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); burner: cross_sub; another_owner: cross_sub;
 		};
-		let item = create_max_item(&collection, &sender, [(burner.clone(), 200), (another_owner, 200)])?;
-	}: {<Pallet<T>>::burn(&collection, &burner, item, 200)?}
+		let item = create_max_item(
+			&collection,
+			&sender,
+			[(burner.clone(), 200), (another_owner, 200)],
+		)?;
+
+		#[block]
+		{
+			<Pallet<T>>::burn(&collection, &burner, item, 200)?;
+		}
+
+		Ok(())
+	}
+
 	// No users remaining, token is destroyed
-	burn_item_fully {
-		bench_init!{
+	#[benchmark]
+	fn burn_item_fully() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
-			sender: cross_from_sub(owner); burner: cross_sub; another_owner: cross_sub;
+			sender: cross_from_sub(owner); burner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, [(burner.clone(), 200)])?;
-	}: {<Pallet<T>>::burn(&collection, &burner, item, 200)?}
 
-	transfer_normal {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::burn(&collection, &burner, item, 200)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn transfer_normal() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); receiver: cross_sub;
 		};
-		let item = create_max_item(&collection, &sender, [(sender.clone(), 200), (receiver.clone(), 200)])?;
-	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 100, &Unlimited)?}
+		let item = create_max_item(
+			&collection,
+			&sender,
+			[(sender.clone(), 200), (receiver.clone(), 200)],
+		)?;
+
+		#[block]
+		{
+			<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 100, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
 	// Target account is created
-	transfer_creating {
-		bench_init!{
+	#[benchmark]
+	fn transfer_creating() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); receiver: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, [(sender.clone(), 200)])?;
-	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 100, &Unlimited)?}
+
+		#[block]
+		{
+			<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 100, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
 	// Source account is destroyed
-	transfer_removing {
-		bench_init!{
+	#[benchmark]
+	fn transfer_removing() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); receiver: cross_sub;
 		};
-		let item = create_max_item(&collection, &sender, [(sender.clone(), 200), (receiver.clone(), 200)])?;
-	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 200, &Unlimited)?}
+		let item = create_max_item(
+			&collection,
+			&sender,
+			[(sender.clone(), 200), (receiver.clone(), 200)],
+		)?;
+
+		#[block]
+		{
+			<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 200, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
 	// Source account destroyed, target created
-	transfer_creating_removing {
-		bench_init!{
+	#[benchmark]
+	fn transfer_creating_removing() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); receiver: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, [(sender.clone(), 200)])?;
-	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 200, &Unlimited)?}
 
-	approve {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::transfer(&collection, &sender, &receiver, item, 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;
 		};
 		let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?;
-	}: {<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 100)?}
 
-	approve_from {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 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());
 		let item = create_max_item(&collection, &owner, [(owner_eth.clone(), 200)])?;
-	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, item, 100)?}
 
-	transfer_from_normal {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, &spender, item, 100)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn transfer_from_normal() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
 		};
-		let item = create_max_item(&collection, &owner, [(sender.clone(), 200), (receiver.clone(), 200)])?;
+		let item = create_max_item(
+			&collection,
+			&owner,
+			[(sender.clone(), 200), (receiver.clone(), 200)],
+		)?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 100)?;
-	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, item, 100, &Unlimited)?}
+
+		#[block]
+		{
+			<Pallet<T>>::transfer_from(
+				&collection,
+				&spender,
+				&sender,
+				&receiver,
+				item,
+				100,
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
 	// Target account is created
-	transfer_from_creating {
-		bench_init!{
+	#[benchmark]
+	fn transfer_from_creating() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
 		};
 		let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 100)?;
-	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, item, 100, &Unlimited)?}
+
+		#[block]
+		{
+			<Pallet<T>>::transfer_from(
+				&collection,
+				&spender,
+				&sender,
+				&receiver,
+				item,
+				100,
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
 	// Source account is destroyed
-	transfer_from_removing {
-		bench_init!{
+	#[benchmark]
+	fn transfer_from_removing() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
 		};
-		let item = create_max_item(&collection, &owner, [(sender.clone(), 200), (receiver.clone(), 200)])?;
+		let item = create_max_item(
+			&collection,
+			&owner,
+			[(sender.clone(), 200), (receiver.clone(), 200)],
+		)?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 200)?;
-	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, item, 200, &Unlimited)?}
+
+		#[block]
+		{
+			<Pallet<T>>::transfer_from(
+				&collection,
+				&spender,
+				&sender,
+				&receiver,
+				item,
+				200,
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
 	// Source account destroyed, target created
-	transfer_from_creating_removing {
-		bench_init!{
+	#[benchmark]
+	fn transfer_from_creating_removing() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; spender: cross_sub; receiver: cross_sub;
 		};
 		let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &spender, item, 200)?;
-	}: {<Pallet<T>>::transfer_from(&collection, &spender, &sender, &receiver, item, 200, &Unlimited)?}
 
+		#[block]
+		{
+			<Pallet<T>>::transfer_from(
+				&collection,
+				&spender,
+				&sender,
+				&receiver,
+				item,
+				200,
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
 	// Both source account and token is destroyed
-	burn_from {
-		bench_init!{
+	#[benchmark]
+	fn burn_from() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; burner: cross_sub;
 		};
 		let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?;
 		<Pallet<T>>::set_allowance(&collection, &sender, &burner, item, 200)?;
-	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, 200, &Unlimited)?}
 
-	set_token_property_permissions {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::burn_from(&collection, &burner, &sender, item, 200, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_token_property_permissions(
+		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
+	) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
-		let perms = (0..b).map(|k| PropertyKeyPermission {
-			key: property_key(k as usize),
-			permission: PropertyPermission {
-				mutable: false,
-				collection_admin: false,
-				token_owner: false,
-			},
-		}).collect::<Vec<_>>();
-	}: {<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?}
+		let perms = (0..b)
+			.map(|k| PropertyKeyPermission {
+				key: property_key(k as usize),
+				permission: PropertyPermission {
+					mutable: false,
+					collection_admin: false,
+					token_owner: false,
+				},
+			})
+			.collect::<Vec<_>>();
 
-	set_token_properties {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
-		let perms = (0..b).map(|k| PropertyKeyPermission {
-			key: property_key(k as usize),
-			permission: PropertyPermission {
-				mutable: false,
-				collection_admin: true,
-				token_owner: true,
-			},
-		}).collect::<Vec<_>>();
+		let perms = (0..b)
+			.map(|k| PropertyKeyPermission {
+				key: property_key(k as usize),
+				permission: PropertyPermission {
+					mutable: false,
+					collection_admin: true,
+					token_owner: true,
+				},
+			})
+			.collect::<Vec<_>>();
 		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
-		let props = (0..b).map(|k| Property {
-			key: property_key(k as usize),
-			value: property_value(),
-		}).collect::<Vec<_>>();
+		let props = (0..b)
+			.map(|k| Property {
+				key: property_key(k as usize),
+				value: property_value(),
+			})
+			.collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
-	}: {<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), &Unlimited)?}
 
-	init_token_properties {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_token_properties(
+				&collection,
+				&owner,
+				item,
+				props.into_iter(),
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn init_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
 
-		let perms = (0..b).map(|k| PropertyKeyPermission {
-			key: property_key(k as usize),
-			permission: PropertyPermission {
-				mutable: false,
-				collection_admin: true,
-				token_owner: true,
-			},
-		}).collect::<Vec<_>>();
+		let perms = (0..b)
+			.map(|k| PropertyKeyPermission {
+				key: property_key(k as usize),
+				permission: PropertyPermission {
+					mutable: false,
+					collection_admin: true,
+					token_owner: true,
+				},
+			})
+			.collect::<Vec<_>>();
 		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
-		let props = (0..b).map(|k| Property {
-			key: property_key(k as usize),
-			value: property_value(),
-		}).collect::<Vec<_>>();
-		let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
+		// let props = (0..b).map(|k| Property {
+		// 	key: property_key(k as usize),
+		// 	value: property_value(),
+		// }).collect::<Vec<_>>();
+		// let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
 
-		let (is_collection_admin, property_permissions) = load_is_admin_and_property_permissions(&collection, &owner);
-	}: {
-		let mut property_writer = pallet_common::collection_info_loaded_property_writer(
-			&collection,
-			is_collection_admin,
-			property_permissions,
-		);
+		// let (is_collection_admin, property_permissions) = load_is_admin_and_property_permissions(&collection, &owner);
 
-		property_writer.write_token_properties(
-			true,
-			item,
-			props.into_iter(),
-			crate::erc::ERC721TokenEvent::TokenChanged {
-				token_id: item.into(),
-			}
-			.to_log(T::ContractAddress::get()),
-		)?
+		#[block]
+		{}
+		todo!();
+		// let mut property_writer = pallet_common::collection_info_loaded_property_writer(
+		// 	&collection,
+		// 	is_collection_admin,
+		// 	property_permissions,
+		// );
+
+		// #[block]
+		// {
+		// 	property_writer.write_token_properties(
+		// 		true,
+		// 		item,
+		// 		props.into_iter(),
+		// 		crate::erc::ERC721TokenEvent::TokenChanged {
+		// 			token_id: item.into(),
+		// 		}
+		// 		.to_log(T::ContractAddress::get()),
+		// 	)?;
+		// }
+
+		Ok(())
 	}
 
-	delete_token_properties {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+	#[benchmark]
+	fn delete_token_properties(
+		b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
+	) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
-		let perms = (0..b).map(|k| PropertyKeyPermission {
-			key: property_key(k as usize),
-			permission: PropertyPermission {
-				mutable: true,
-				collection_admin: true,
-				token_owner: true,
-			},
-		}).collect::<Vec<_>>();
+		let perms = (0..b)
+			.map(|k| PropertyKeyPermission {
+				key: property_key(k as usize),
+				permission: PropertyPermission {
+					mutable: true,
+					collection_admin: true,
+					token_owner: true,
+				},
+			})
+			.collect::<Vec<_>>();
 		<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
-		let props = (0..b).map(|k| Property {
-			key: property_key(k as usize),
-			value: property_value(),
-		}).collect::<Vec<_>>();
+		let props = (0..b)
+			.map(|k| Property {
+				key: property_key(k as usize),
+				value: property_value(),
+			})
+			.collect::<Vec<_>>();
 		let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
-		<Pallet<T>>::set_token_properties(&collection, &owner, item, props.into_iter(), &Unlimited)?;
+		<Pallet<T>>::set_token_properties(
+			&collection,
+			&owner,
+			item,
+			props.into_iter(),
+			&Unlimited,
+		)?;
 		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
-	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?}
 
-	repartition_item {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::delete_token_properties(
+				&collection,
+				&owner,
+				item,
+				to_delete.into_iter(),
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn repartition_item() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); owner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, [(owner.clone(), 100)])?;
-	}: {<Pallet<T>>::repartition(&collection, &owner, item, 200)?}
 
-	token_owner {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::repartition(&collection, &owner, item, 200)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn token_owner() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); owner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, [(owner, 100)])?;
-	}: {<Pallet<T>>::token_owner(collection.id, item).unwrap()}
 
-	set_allowance_for_all {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::token_owner(collection.id, item).unwrap();
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_allowance_for_all() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner); owner: cross_from_sub;
 			operator: cross_sub;
 		};
-	}: {<Pallet<T>>::set_allowance_for_all(&collection, &owner, &operator, true)?}
 
-	allowance_for_all {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance_for_all(&collection, &owner, &operator, true)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn allowance_for_all() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner); owner: cross_from_sub;
 			operator: cross_sub;
 		};
-	}: {<Pallet<T>>::allowance_for_all(&collection, &owner, &operator)}
 
-	repair_item {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::allowance_for_all(&collection, &owner, &operator);
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn repair_item() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
 		let item = create_max_item(&collection, &owner, [(owner.clone(), 100)])?;
-	}: {<Pallet<T>>::repair_item(&collection, item)?}
+
+		#[block]
+		{
+			<Pallet<T>>::repair_item(&collection, item)?;
+		}
+
+		Ok(())
+	}
 }

--- a/pallets/structure/src/benchmarking.rs
+++ b/pallets/structure/src/benchmarking.rs
@@ -14,10 +14,11 @@
 // 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::v2::{account, benchmarks, BenchmarkError};
 use frame_support::traits::{fungible::Balanced, tokens::Precision, Get};
 use pallet_common::Config as CommonConfig;
 use pallet_evm::account::CrossAccountId;
+use sp_std::vec;
 use up_data_structs::{
 	budget::Unlimited, CollectionMode, CreateCollectionData, CreateItemData, CreateNftData,
 };
@@ -26,12 +27,21 @@
 
 const SEED: u32 = 1;
 
-benchmarks! {
-	find_parent {
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn find_parent() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let caller_cross = T::CrossAccountId::from_sub(caller.clone());
 
-		let _ = <T as CommonConfig>::Currency::deposit(&caller, T::CollectionCreationPrice::get(), Precision::Exact).unwrap();
+		let _ = <T as CommonConfig>::Currency::deposit(
+			&caller,
+			T::CollectionCreationPrice::get(),
+			Precision::Exact,
+		)
+		.unwrap();
 		T::CollectionDispatch::create(
 			caller_cross.clone(),
 			caller_cross.clone(),
@@ -43,9 +53,19 @@
 		let dispatch = T::CollectionDispatch::dispatch(CollectionId(1))?;
 		let dispatch = dispatch.as_dyn();
 
-		dispatch.create_item(caller_cross.clone(), caller_cross, CreateItemData::NFT(CreateNftData::default()), &Unlimited)?;
-	}: {
-		let parent = <Pallet<T>>::find_parent(CollectionId(1), TokenId(1))?;
-		assert!(matches!(parent, Parent::User(_)))
+		dispatch.create_item(
+			caller_cross.clone(),
+			caller_cross,
+			CreateItemData::NFT(CreateNftData::default()),
+			&Unlimited,
+		)?;
+
+		#[block]
+		{
+			let parent = <Pallet<T>>::find_parent(CollectionId(1), TokenId(1))?;
+			assert!(matches!(parent, Parent::User(_)));
+		}
+
+		Ok(())
 	}
 }

--- a/pallets/unique/src/benchmarking.rs
+++ b/pallets/unique/src/benchmarking.rs
@@ -16,7 +16,7 @@
 
 #![cfg(feature = "runtime-benchmarks")]
 
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::v2::{account, benchmarks, BenchmarkError};
 use frame_support::traits::{fungible::Balanced, tokens::Precision, Get};
 use frame_system::RawOrigin;
 use pallet_common::{
@@ -63,81 +63,201 @@
 	create_collection_helper::<T>(owner, CollectionMode::NFT)
 }
 
-benchmarks! {
-	create_collection {
-		let col_name = create_u16_data::<{MAX_COLLECTION_NAME_LENGTH}>();
-		let col_desc = create_u16_data::<{MAX_COLLECTION_DESCRIPTION_LENGTH}>();
-		let token_prefix = create_data::<{MAX_TOKEN_PREFIX_LENGTH}>();
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn create_collection() -> Result<(), BenchmarkError> {
+		let col_name = create_u16_data::<{ MAX_COLLECTION_NAME_LENGTH }>();
+		let col_desc = create_u16_data::<{ MAX_COLLECTION_DESCRIPTION_LENGTH }>();
+		let token_prefix = create_data::<{ MAX_TOKEN_PREFIX_LENGTH }>();
 		let mode: CollectionMode = CollectionMode::NFT;
 		let caller: T::AccountId = account("caller", 0, SEED);
-		let _ = <T as CommonConfig>::Currency::deposit(&caller, T::CollectionCreationPrice::get(), Precision::Exact).unwrap();
-	}: _(RawOrigin::Signed(caller.clone()), col_name, col_desc, token_prefix, mode)
-	verify {
-		assert_eq!(<pallet_common::CollectionById<T>>::get(CollectionId(1)).unwrap().owner, caller);
+		let _ = <T as CommonConfig>::Currency::deposit(
+			&caller,
+			T::CollectionCreationPrice::get(),
+			Precision::Exact,
+		)
+		.unwrap();
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			col_name,
+			col_desc,
+			token_prefix,
+			mode,
+		);
+
+		assert_eq!(
+			<pallet_common::CollectionById<T>>::get(CollectionId(1))
+				.unwrap()
+				.owner,
+			caller
+		);
+
+		Ok(())
 	}
 
-	destroy_collection {
+	#[benchmark]
+	fn destroy_collection() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection)
 
-	add_to_allow_list {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), collection);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn add_to_allow_list() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let allowlist_account: T::AccountId = account("admin", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(allowlist_account))
 
-	remove_from_allow_list {
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			collection,
+			T::CrossAccountId::from_sub(allowlist_account),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn remove_from_allow_list() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let allowlist_account: T::AccountId = account("admin", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-		<Pallet<T>>::add_to_allow_list(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(allowlist_account.clone()))?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(allowlist_account))
+		<Pallet<T>>::add_to_allow_list(
+			RawOrigin::Signed(caller.clone()).into(),
+			collection,
+			T::CrossAccountId::from_sub(allowlist_account.clone()),
+		)?;
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			collection,
+			T::CrossAccountId::from_sub(allowlist_account),
+		);
+
+		Ok(())
+	}
 
-	change_collection_owner {
+	#[benchmark]
+	fn change_collection_owner() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 		let new_owner: T::AccountId = account("admin", 0, SEED);
-	}: _(RawOrigin::Signed(caller.clone()), collection, new_owner)
 
-	add_collection_admin {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), collection, new_owner);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn add_collection_admin() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 		let new_admin: T::AccountId = account("admin", 0, SEED);
-	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))
 
-	remove_collection_admin {
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			collection,
+			T::CrossAccountId::from_sub(new_admin),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn remove_collection_admin() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 		let new_admin: T::AccountId = account("admin", 0, SEED);
-		<Pallet<T>>::add_collection_admin(RawOrigin::Signed(caller.clone()).into(), collection, T::CrossAccountId::from_sub(new_admin.clone()))?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, T::CrossAccountId::from_sub(new_admin))
+		<Pallet<T>>::add_collection_admin(
+			RawOrigin::Signed(caller.clone()).into(),
+			collection,
+			T::CrossAccountId::from_sub(new_admin.clone()),
+		)?;
+
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			collection,
+			T::CrossAccountId::from_sub(new_admin),
+		);
+
+		Ok(())
+	}
 
-	set_collection_sponsor {
+	#[benchmark]
+	fn set_collection_sponsor() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, caller.clone())
 
-	confirm_sponsorship {
+		#[extrinsic_call]
+		_(
+			RawOrigin::Signed(caller.clone()),
+			collection,
+			caller.clone(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn confirm_sponsorship() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), collection, caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection)
+		<Pallet<T>>::set_collection_sponsor(
+			RawOrigin::Signed(caller.clone()).into(),
+			collection,
+			caller.clone(),
+		)?;
 
-	remove_collection_sponsor {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), collection);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn remove_collection_sponsor() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-		<Pallet<T>>::set_collection_sponsor(RawOrigin::Signed(caller.clone()).into(), collection, caller.clone())?;
+		<Pallet<T>>::set_collection_sponsor(
+			RawOrigin::Signed(caller.clone()).into(),
+			collection,
+			caller.clone(),
+		)?;
 		<Pallet<T>>::confirm_sponsorship(RawOrigin::Signed(caller.clone()).into(), collection)?;
-	}: _(RawOrigin::Signed(caller.clone()), collection)
 
-	set_transfers_enabled_flag {
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), collection);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_transfers_enabled_flag() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
-	}: _(RawOrigin::Signed(caller.clone()), collection, false)
 
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), collection, false);
 
-	set_collection_limits {
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_collection_limits() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller.clone())?;
 
@@ -152,10 +272,21 @@
 			sponsored_data_rate_limit: None,
 			transfers_enabled: Some(true),
 		};
-	}: set_collection_limits(RawOrigin::Signed(caller.clone()), collection, cl)
 
-	force_repair_collection {
+		#[extrinsic_call]
+		set_collection_limits(RawOrigin::Signed(caller.clone()), collection, cl);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn force_repair_collection() -> Result<(), BenchmarkError> {
 		let caller: T::AccountId = account("caller", 0, SEED);
 		let collection = create_nft_collection::<T>(caller)?;
-	}: _(RawOrigin::Root, collection)
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, collection);
+
+		Ok(())
+	}
 }