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/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(())
 	}
 }

--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/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::v2::{account, benchmarks, BenchmarkError};
 use pallet_common::{
 	bench_init,
 	benchmarking::{
@@ -64,236 +64,437 @@
 	)
 }
 
-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())?}
 
-	create_multiple_items {
-		let b in 0..MAX_ITEMS_PER_BATCH;
-		bench_init!{
+		#[block]
+		{
+			create_max_item(&collection, &sender, to.clone())?;
+		}
+
+		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())).collect();
-	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
+		let data = (0..b)
+			.map(|_| create_max_item_data::<T>(to.clone()))
+			.collect();
 
-	create_multiple_items_ex {
-		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(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););
-			create_max_item_data::<T>(to)
-		}).collect();
-	}: {<Pallet<T>>::create_multiple_items(&collection, &sender, data, &Unlimited)?}
+		let data = (0..b)
+			.map(|i| {
+				bench_init!(to: cross_sub(i););
+				create_max_item_data::<T>(to)
+			})
+			.collect();
+
+		#[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);
 			sender: cross_from_sub(owner); burner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, burner.clone())?;
-	}: {<Pallet<T>>::burn(&collection, &burner, item)?}
 
-	burn_recursively_self_raw {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::burn(&collection, &burner, item)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn burn_recursively_self_raw() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); burner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, burner.clone())?;
-	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
 
-	burn_recursively_breadth_plus_self_plus_self_per_each_raw {
-		let b in 0..200;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(
+		b: Linear<0, 200>,
+	) -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			sender: cross_from_sub(owner); burner: cross_sub;
 		};
 		let item = create_max_item(&collection, &sender, burner.clone())?;
-		for i in 0..b {
-			create_max_item(&collection, &sender, T::CrossTokenAddressMapping::token_to_address(collection.id, item))?;
+		for _ in 0..b {
+			create_max_item(
+				&collection,
+				&sender,
+				T::CrossTokenAddressMapping::token_to_address(collection.id, item),
+			)?;
+		}
+
+		#[block]
+		{
+			<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
 		}
-	}: {<Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?}
 
-	transfer_raw {
-		bench_init!{
+		Ok(())
+	}
+
+	#[benchmark]
+	fn transfer_raw() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub; sender: cross_sub; receiver: cross_sub;
 		};
 		let item = create_max_item(&collection, &owner, sender.clone())?;
-	}: {<Pallet<T>>::transfer(&collection, &sender, &receiver, item, &Unlimited)?}
 
-	approve {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::transfer(&collection, &sender, &receiver, item, &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())?;
-	}: {<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?}
 
-	approve_from {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;
+		}
+
+		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())?;
-	}: {<Pallet<T>>::set_allowance_from(&collection, &sender, &owner_eth, item, Some(&spender))?}
 
-	check_allowed_raw {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::set_allowance_from(
+				&collection,
+				&sender,
+				&owner_eth,
+				item,
+				Some(&spender),
+			)?;
+		}
+
+		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; receiver: cross_sub;
+			owner: cross_from_sub; sender: cross_sub; spender: cross_sub;
 		};
 		let item = create_max_item(&collection, &owner, sender.clone())?;
 		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&spender))?;
-	}: {<Pallet<T>>::check_allowed(&collection, &spender, &sender, item, &Unlimited)?}
 
-	burn_from {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::check_allowed(&collection, &spender, &sender, item, &Unlimited)?;
+		}
+
+		Ok(())
+	}
+
+	#[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())?;
 		<Pallet<T>>::set_allowance(&collection, &sender, item, Some(&burner))?;
-	}: {<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &Unlimited)?}
 
-	set_token_property_permissions {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::burn_from(&collection, &burner, &sender, item, &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<_>>();
+
+		#[block]
+		{
+			<Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+		}
 
-	set_token_properties {
-		let b in 0..MAX_PROPERTIES_PER_ITEM;
-		bench_init!{
+		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())?;
-	}: {<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 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())?;
 
-		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);
+		todo!();
+		#[block]
+		{}
+		// 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()),
+		// 	)?;
+		// }
 
-		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())?;
-		<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)?}
 
-	token_owner {
-		bench_init!{
+		#[block]
+		{
+			<Pallet<T>>::delete_token_properties(
+				&collection,
+				&owner,
+				item,
+				to_delete.into_iter(),
+				&Unlimited,
+			)?;
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn token_owner() -> Result<(), BenchmarkError> {
+		bench_init! {
 			owner: sub; collection: collection(owner);
 			owner: cross_from_sub;
 		};
 		let item = create_max_item(&collection, &owner, owner.clone())?;
-	}: {collection.token_owner(item).unwrap()}
 
-	set_allowance_for_all {
-		bench_init!{
+		#[block]
+		{
+			collection.token_owner(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())?;
-	}: {<Pallet<T>>::repair_item(&collection, item)?}
+
+		#[block]
+		{
+			<Pallet<T>>::repair_item(&collection, item)?;
+		}
+
+		Ok(())
+	}
 }

--- 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(())
+	}
 }