git.delta.rocks / unique-network / refs/commits / f9edb50d1095

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5307,6 +5307,7 @@
  "pallet-common",
  "pallet-evm",
  "pallet-evm-contract-helpers",
+ "pallet-evm-migration",
  "pallet-randomness-collective-flip",
  "pallet-timestamp",
  "pallet-unique",

--- a/pallets/app-promotion/Cargo.toml
+++ b/pallets/app-promotion/Cargo.toml
@@ -15,7 +15,7 @@
 targets = ['x86_64-unknown-linux-gnu']
 
 [features]
-default = ['std']
+default = ['std',]
 runtime-benchmarks = [
     'frame-benchmarking',
     'frame-support/runtime-benchmarks',
@@ -121,6 +121,13 @@
 [dependencies.pallet-evm-contract-helpers]
 default-features = false
 path =  "../evm-contract-helpers"
+
+[dev-dependencies]
+[dependencies.pallet-evm-migration]
+default-features = false
+path =  "../evm-migration"
+
+
 ################################################################################
 
 [dependencies]

--- a/pallets/app-promotion/src/benchmarking.rs
+++ b/pallets/app-promotion/src/benchmarking.rs
@@ -20,53 +20,109 @@
 use crate::Pallet as PromototionPallet;
 
 use sp_runtime::traits::Bounded;
+use sp_std::vec;
 
 use frame_benchmarking::{benchmarks, account};
-use frame_support::traits::OnInitialize;
+
 use frame_system::{Origin, RawOrigin};
+use pallet_unique::benchmarking::create_nft_collection;
+use pallet_evm_migration::Pallet as EvmMigrationPallet;
+
+// trait BenchmarkingConfig: Config + pallet_unique::Config { }
+
+// impl<T: Config + pallet_unique::Config> BenchmarkingConfig for T { }
 
 const SEED: u32 = 0;
 benchmarks! {
 	where_clause{
-		where T: Config
-
+		where T:  Config + pallet_unique::Config + pallet_evm_migration::Config ,
+		T::BlockNumber: From<u32>
 	}
-	on_initialize {
-		let block1: T::BlockNumber = T::BlockNumber::from(1u32);
-		let block2: T::BlockNumber = T::BlockNumber::from(2u32);
-		PromototionPallet::<T>::on_initialize(block1); // Create Treasury account
-	}: { PromototionPallet::<T>::on_initialize(block2); } // Benchmark deposit_into_existing path
-
 	start_app_promotion {
-		let caller = account::<T::AccountId>("caller", 0, SEED);
 
-	} : {PromototionPallet::<T>::start_app_promotion(RawOrigin::Root.into(), T::BlockNumber::from(2u32))?}
+	} : {PromototionPallet::<T>::start_app_promotion(RawOrigin::Root.into(), None)?}
+
+	stop_app_promotion{
+		PromototionPallet::<T>::start_app_promotion(RawOrigin::Root.into(), Some(25.into()))?;
+	} : {PromototionPallet::<T>::stop_app_promotion(RawOrigin::Root.into())?}
 
 	set_admin_address {
-		let caller = account::<T::AccountId>("caller", 0, SEED);
-		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-	} : {PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), caller)?}
+		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
+		let _ = <T as Config>::Currency::make_free_balance_be(&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))?}
 
+	payout_stakers{
+		let pallet_admin = account::<T::AccountId>("admin", 0, SEED);
+		let share = Perbill::from_rational(1u32, 10);
+		PromototionPallet::<T>::set_admin_address(RawOrigin::Root.into(), T::CrossAccountId::from_sub(pallet_admin.clone()))?;
+		let _ = <T as Config>::Currency::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let staker: T::AccountId = account("caller", 0, SEED);
+		let _ = <T as Config>::Currency::make_free_balance_be(&staker,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(staker.clone()).into(), share * <T as Config>::Currency::total_balance(&staker))?;
+	} : {PromototionPallet::<T>::payout_stakers(RawOrigin::Signed(pallet_admin.clone()).into(), Some(1))?}
+
 	stake {
 		let caller = account::<T::AccountId>("caller", 0, SEED);
 		let share = Perbill::from_rational(1u32, 10);
-		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-	} : {PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}
+		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+	} : {PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?}
 
 	unstake {
 		let caller = account::<T::AccountId>("caller", 0, SEED);
 		let share = Perbill::from_rational(1u32, 10);
-		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?;
+		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?;
 
-	} : {PromototionPallet::<T>::unstake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?}
+	} : {PromototionPallet::<T>::unstake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?}
 
 	recalculate_stake {
 		let caller = account::<T::AccountId>("caller", 0, SEED);
 		let share = Perbill::from_rational(1u32, 10);
-		let _ = T::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
-		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * T::Currency::total_balance(&caller))?;
-		let block = <T::BlockNumberProvider as BlockNumberProvider>::current_block_number();
+		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let _ = PromototionPallet::<T>::stake(RawOrigin::Signed(caller.clone()).into(), share * <T as Config>::Currency::total_balance(&caller))?;
+		let block = <T::RelayBlockNumberProvider as BlockNumberProvider>::current_block_number();
 		let mut acc = <BalanceOf<T>>::default();
-	} : {PromototionPallet::<T>::recalculate_stake(&caller, block, share * T::Currency::total_balance(&caller), &mut acc)}
+	} : {PromototionPallet::<T>::recalculate_stake(&caller, block, share * <T as Config>::Currency::total_balance(&caller), &mut acc)}
+
+	sponsor_collection {
+		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::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let caller: T::AccountId = account("caller", 0, SEED);
+		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let collection = create_nft_collection::<T>(caller.clone())?;
+	} : {PromototionPallet::<T>::sponsor_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?}
+
+	stop_sponsoring_collection {
+		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::make_free_balance_be(&pallet_admin,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let caller: T::AccountId = account("caller", 0, SEED);
+		let _ = <T as Config>::Currency::make_free_balance_be(&caller,  Perbill::from_rational(1u32, 2) * BalanceOf::<T>::max_value());
+		let collection = create_nft_collection::<T>(caller.clone())?;
+		PromototionPallet::<T>::sponsor_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?;
+	} : {PromototionPallet::<T>::stop_sponsoring_collection(RawOrigin::Signed(pallet_admin.clone()).into(), collection)?}
+
+	sponsor_contract {
+		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::make_free_balance_be(&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 as u8).collect();
+		<EvmMigrationPallet<T>>::begin(RawOrigin::Root.into(), address)?;
+		<EvmMigrationPallet<T>>::finish(RawOrigin::Root.into(), address, data)?;
+	} : {PromototionPallet::<T>::sponsor_conract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?}
+
+	stop_sponsoring_contract {
+		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::make_free_balance_be(&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 as u8).collect();
+		<EvmMigrationPallet<T>>::begin(RawOrigin::Root.into(), address)?;
+		<EvmMigrationPallet<T>>::finish(RawOrigin::Root.into(), address, data)?;
+		PromototionPallet::<T>::sponsor_conract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?;
+	} : {PromototionPallet::<T>::stop_sponsoring_contract(RawOrigin::Signed(pallet_admin.clone()).into(), address)?}
 }

--- a/pallets/app-promotion/src/lib.rs
+++ b/pallets/app-promotion/src/lib.rs
@@ -132,6 +132,8 @@
 	#[pallet::generate_deposit(fn deposit_event)]
 	pub enum Event<T: Config> {
 		StakingRecalculation(
+			/// An recalculated staker
+			T::AccountId,
 			/// Base on which interest is calculated
 			BalanceOf<T>,
 			/// Amount of accrued interest
@@ -164,7 +166,7 @@
 			Key<Blake2_128Concat, T::AccountId>,
 			Key<Twox64Concat, T::BlockNumber>,
 		),
-		Value = BalanceOf<T>,
+		Value = (BalanceOf<T>, T::BlockNumber),
 		QueryKind = ValueQuery,
 	>;
 
@@ -189,6 +191,13 @@
 	pub type NextInterestBlock<T: Config> =
 		StorageValue<Value = T::BlockNumber, QueryKind = ValueQuery>;
 
+	/// Stores the address of the staker for which the last revenue recalculation was performed.
+	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.
+	#[pallet::storage]
+	#[pallet::getter(fn get_last_calculated_staker)]
+	pub type LastCalcucaltedStaker<T: Config> =
+		StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;
+
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(current_block: T::BlockNumber) -> Weight
@@ -196,10 +205,10 @@
 			<T as frame_system::Config>::BlockNumber: From<u32>,
 		{
 			let mut consumed_weight = 0;
-			let mut add_weight = |reads, writes, weight| {
-				consumed_weight += T::DbWeight::get().reads_writes(reads, writes);
-				consumed_weight += weight;
-			};
+			// let mut add_weight = |reads, writes, weight| {
+			// 	consumed_weight += T::DbWeight::get().reads_writes(reads, writes);
+			// 	consumed_weight += weight;
+			// };
 
 			PendingUnstake::<T>::iter()
 				.filter_map(|((staker, block), amount)| {
@@ -214,41 +223,44 @@
 					<PendingUnstake<T>>::remove((staker, block));
 				});
 
-			let next_interest_block = Self::get_interest_block();
-			let current_relay_block = T::RelayBlockNumberProvider::current_block_number();
-			if next_interest_block != 0.into() && current_relay_block >= next_interest_block {
-				let mut acc = <BalanceOf<T>>::default();
-				let mut base_acc = <BalanceOf<T>>::default();
+			// let next_interest_block = Self::get_interest_block();
+			// let current_relay_block = T::RelayBlockNumberProvider::current_block_number();
+			// if next_interest_block != 0.into() && current_relay_block >= next_interest_block {
+			// 	let mut acc = <BalanceOf<T>>::default();
+			// 	let mut base_acc = <BalanceOf<T>>::default();
 
-				NextInterestBlock::<T>::set(
-					NextInterestBlock::<T>::get() + T::RecalculationInterval::get(),
-				);
-				add_weight(0, 1, 0);
+			// 	NextInterestBlock::<T>::set(
+			// 		NextInterestBlock::<T>::get() + T::RecalculationInterval::get(),
+			// 	);
+			// 	add_weight(0, 1, 0);
 
-				Staked::<T>::iter()
-					.filter(|((_, block), _)| {
-						*block + T::RecalculationInterval::get() <= current_relay_block
-					})
-					.for_each(|((staker, block), amount)| {
-						Self::recalculate_stake(&staker, block, amount, &mut acc);
-						add_weight(0, 0, T::WeightInfo::recalculate_stake());
-						base_acc += amount;
-					});
-				<TotalStaked<T>>::get()
-					.checked_add(&acc)
-					.map(|res| <TotalStaked<T>>::set(res));
+			// 	Staked::<T>::iter()
+			// 		.filter(|((_, block), _)| {
+			// 			*block + T::RecalculationInterval::get() <= current_relay_block
+			// 		})
+			// 		.for_each(|((staker, block), amount)| {
+			// 			Self::recalculate_stake(&staker, block, amount, &mut acc);
+			// 			add_weight(0, 0, T::WeightInfo::recalculate_stake());
+			// 			base_acc += amount;
+			// 		});
+			// 	<TotalStaked<T>>::get()
+			// 		.checked_add(&acc)
+			// 		.map(|res| <TotalStaked<T>>::set(res));
 
-				Self::deposit_event(Event::StakingRecalculation(base_acc, acc));
-				add_weight(0, 1, 0);
-			} else {
-				add_weight(1, 0, 0)
-			};
+			// 	Self::deposit_event(Event::StakingRecalculation(base_acc, acc));
+			// 	add_weight(0, 1, 0);
+			// } else {
+			// 	add_weight(1, 0, 0)
+			// };
 			consumed_weight
 		}
 	}
 
 	#[pallet::call]
-	impl<T: Config> Pallet<T> {
+	impl<T: Config> Pallet<T>
+	where
+		T::BlockNumber: From<u32>,
+	{
 		#[pallet::weight(T::WeightInfo::set_admin_address())]
 		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {
 			ensure_root(origin)?;
@@ -281,7 +293,7 @@
 			Ok(())
 		}
 
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::stop_app_promotion())]
 		pub fn stop_app_promotion(origin: OriginFor<T>) -> DispatchResult
 		where
 			<T as frame_system::Config>::BlockNumber: From<u32>,
@@ -317,19 +329,24 @@
 			Self::add_lock_balance(&staker_id, amount)?;
 
 			let block_number = T::RelayBlockNumberProvider::current_block_number();
+			let recalc_block = (block_number / T::RecalculationInterval::get() + 2u32.into())
+				* T::RecalculationInterval::get();
 
-			<Staked<T>>::insert(
-				(&staker_id, block_number),
-				<Staked<T>>::get((&staker_id, block_number))
+			<Staked<T>>::insert((&staker_id, block_number), {
+				let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));
+				balance_and_recalc_block.0 = balance_and_recalc_block
+					.0
 					.checked_add(&amount)
-					.ok_or(ArithmeticError::Overflow)?,
-			);
+					.ok_or(ArithmeticError::Overflow)?;
+				balance_and_recalc_block.1 = recalc_block;
+				balance_and_recalc_block
+			});
 
-			<TotalStaked<T>>::set(
-				<TotalStaked<T>>::get()
-					.checked_add(&amount)
-					.ok_or(ArithmeticError::Overflow)?,
-			);
+			// <TotalStaked<T>>::set(
+			// 	<TotalStaked<T>>::get()
+			// 		.checked_add(&amount)
+			// 		.ok_or(ArithmeticError::Overflow)?,
+			// );
 
 			Ok(())
 		}
@@ -338,63 +355,120 @@
 		pub fn unstake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {
 			let staker_id = ensure_signed(staker)?;
 
-			let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();
+			let mut stakes = Staked::<T>::drain_prefix((&staker_id,));
 
-			let total_staked = stakes
-				.iter()
-				.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + *amount);
+			// let total_staked = stakes
+			// 	.iter()
+			// 	.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + *amount);
 
-			ensure!(total_staked >= amount, ArithmeticError::Underflow);
+			// ensure!(total_staked >= amount, ArithmeticError::Underflow);
 
-			<TotalStaked<T>>::set(
-				<TotalStaked<T>>::get()
-					.checked_sub(&amount)
-					.ok_or(ArithmeticError::Underflow)?,
-			);
+			// <TotalStaked<T>>::set(
+			// 	<TotalStaked<T>>::get()
+			// 		.checked_sub(&amount)
+			// 		.ok_or(ArithmeticError::Underflow)?,
+			// );
 
-			let block =
-				T::RelayBlockNumberProvider::current_block_number() + T::PendingInterval::get();
-			<PendingUnstake<T>>::insert(
-				(&staker_id, block),
-				<PendingUnstake<T>>::get((&staker_id, block))
-					.checked_add(&amount)
-					.ok_or(ArithmeticError::Overflow)?,
-			);
+			// let block =
+			// 	T::RelayBlockNumberProvider::current_block_number() + T::PendingInterval::get();
+			// <PendingUnstake<T>>::insert(
+			// 	(&staker_id, block),
+			// 	<PendingUnstake<T>>::get((&staker_id, block))
+			// 		.checked_add(&amount)
+			// 		.ok_or(ArithmeticError::Overflow)?,
+			// );
 
-			stakes.sort_by_key(|(block, _)| *block);
+			// stakes.sort_by_key(|(block, _)| *block);
 
-			let mut acc_amount = amount;
-			let new_state = stakes
-				.into_iter()
-				.map_while(|(block, balance_per_block)| {
-					if acc_amount == <BalanceOf<T>>::default() {
-						return None;
-					}
-					if acc_amount <= balance_per_block {
-						let res = (block, balance_per_block - acc_amount, acc_amount);
-						acc_amount = <BalanceOf<T>>::default();
-						return Some(res);
-					} else {
-						acc_amount -= balance_per_block;
-						return Some((block, <BalanceOf<T>>::default(), acc_amount));
-					}
-				})
-				.collect::<Vec<_>>();
+			// let mut acc_amount = amount;
+			// let new_state = stakes
+			// 	.into_iter()
+			// 	.map_while(|(block, balance_per_block)| {
+			// 		if acc_amount == <BalanceOf<T>>::default() {
+			// 			return None;
+			// 		}
+			// 		if acc_amount <= balance_per_block {
+			// 			let res = (block, balance_per_block - acc_amount, acc_amount);
+			// 			acc_amount = <BalanceOf<T>>::default();
+			// 			return Some(res);
+			// 		} else {
+			// 			acc_amount -= balance_per_block;
+			// 			return Some((block, <BalanceOf<T>>::default(), acc_amount));
+			// 		}
+			// 	})
+			// 	.collect::<Vec<_>>();
 
-			new_state
-				.into_iter()
-				.for_each(|(block, to_staked, _to_pending)| {
-					if to_staked == <BalanceOf<T>>::default() {
-						<Staked<T>>::remove((&staker_id, block));
-					} else {
-						<Staked<T>>::insert((&staker_id, block), to_staked);
-					}
-				});
+			// new_state
+			// 	.into_iter()
+			// 	.for_each(|(block, to_staked, _to_pending)| {
+			// 		if to_staked == <BalanceOf<T>>::default() {
+			// 			<Staked<T>>::remove((&staker_id, block));
+			// 		} else {
+			// 			<Staked<T>>::insert((&staker_id, block), to_staked);
+			// 		}
+			// 	});
 
 			Ok(())
+
+			// let staker_id = ensure_signed(staker)?;
+
+			// let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();
+
+			// let total_staked = stakes
+			// 	.iter()
+			// 	.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + *amount);
+
+			// ensure!(total_staked >= amount, ArithmeticError::Underflow);
+
+			// <TotalStaked<T>>::set(
+			// 	<TotalStaked<T>>::get()
+			// 		.checked_sub(&amount)
+			// 		.ok_or(ArithmeticError::Underflow)?,
+			// );
+
+			// let block =
+			// 	T::RelayBlockNumberProvider::current_block_number() + T::PendingInterval::get();
+			// <PendingUnstake<T>>::insert(
+			// 	(&staker_id, block),
+			// 	<PendingUnstake<T>>::get((&staker_id, block))
+			// 		.checked_add(&amount)
+			// 		.ok_or(ArithmeticError::Overflow)?,
+			// );
+
+			// stakes.sort_by_key(|(block, _)| *block);
+
+			// let mut acc_amount = amount;
+			// let new_state = stakes
+			// 	.into_iter()
+			// 	.map_while(|(block, balance_per_block)| {
+			// 		if acc_amount == <BalanceOf<T>>::default() {
+			// 			return None;
+			// 		}
+			// 		if acc_amount <= balance_per_block {
+			// 			let res = (block, balance_per_block - acc_amount, acc_amount);
+			// 			acc_amount = <BalanceOf<T>>::default();
+			// 			return Some(res);
+			// 		} else {
+			// 			acc_amount -= balance_per_block;
+			// 			return Some((block, <BalanceOf<T>>::default(), acc_amount));
+			// 		}
+			// 	})
+			// 	.collect::<Vec<_>>();
+
+			// new_state
+			// 	.into_iter()
+			// 	.for_each(|(block, to_staked, _to_pending)| {
+			// 		if to_staked == <BalanceOf<T>>::default() {
+			// 			<Staked<T>>::remove((&staker_id, block));
+			// 		} else {
+			// 			<Staked<T>>::insert((&staker_id, block), to_staked);
+			// 		}
+			// 	});
+
+			// Ok(())
 		}
 
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::sponsor_collection())]
 		pub fn sponsor_collection(
 			admin: OriginFor<T>,
 			collection_id: CollectionId,
@@ -407,8 +481,8 @@
 
 			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)
 		}
-		#[pallet::weight(0)]
-		pub fn stop_sponsorign_collection(
+		#[pallet::weight(T::WeightInfo::stop_sponsoring_collection())]
+		pub fn stop_sponsoring_collection(
 			admin: OriginFor<T>,
 			collection_id: CollectionId,
 		) -> DispatchResult {
@@ -428,7 +502,7 @@
 			T::CollectionHandler::remove_collection_sponsor(collection_id)
 		}
 
-		#[pallet::weight(0)]
+		#[pallet::weight(T::WeightInfo::sponsor_contract())]
 		pub fn sponsor_conract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {
 			let admin_id = ensure_signed(admin)?;
 
@@ -443,8 +517,8 @@
 			)
 		}
 
-		#[pallet::weight(0)]
-		pub fn stop_sponsorign_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {
+		#[pallet::weight(T::WeightInfo::stop_sponsoring_contract())]
+		pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {
 			let admin_id = ensure_signed(admin)?;
 
 			ensure!(
@@ -459,6 +533,18 @@
 			);
 			T::ContractHandler::remove_contract_sponsor(contract_id)
 		}
+
+		#[pallet::weight(0)]
+		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {
+			let admin_id = ensure_signed(admin)?;
+
+			ensure!(
+				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,
+				Error::<T>::NoPermission
+			);
+
+			Ok(())
+		}
 	}
 }
 
@@ -501,7 +587,9 @@
 	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {
 		let staked = Staked::<T>::iter_prefix((staker,))
 			.into_iter()
-			.fold(<BalanceOf<T>>::default(), |acc, (_, amount)| acc + amount);
+			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {
+				acc + amount
+			});
 		if staked != <BalanceOf<T>>::default() {
 			Some(staked)
 		} else {
@@ -514,7 +602,7 @@
 	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {
 		let mut staked = Staked::<T>::iter_prefix((staker,))
 			.into_iter()
-			.map(|(block, amount)| (block, amount))
+			.map(|(block, (amount, _))| (block, amount))
 			.collect::<Vec<_>>();
 		staked.sort_by_key(|(block, _)| *block);
 		if !staked.is_empty() {
@@ -550,17 +638,17 @@
 		income_acc: &mut BalanceOf<T>,
 	) {
 		let income = Self::calculate_income(base);
-		base.checked_add(&income).map(|res| {
-			<Staked<T>>::insert((staker, block), res);
-			*income_acc += income;
-			<T::Currency as Currency<T::AccountId>>::transfer(
-				&T::TreasuryAccountId::get(),
-				staker,
-				income,
-				ExistenceRequirement::KeepAlive,
-			)
-			.and_then(|_| Self::add_lock_balance(staker, income));
-		});
+		// base.checked_add(&income).map(|res| {
+		// 	<Staked<T>>::insert((staker, block), res);
+		// 	*income_acc += income;
+		// 	<T::Currency as Currency<T::AccountId>>::transfer(
+		// 		&T::TreasuryAccountId::get(),
+		// 		staker,
+		// 		income,
+		// 		ExistenceRequirement::KeepAlive,
+		// 	)
+		// 	.and_then(|_| Self::add_lock_balance(staker, income));
+		// });
 	}
 
 	fn calculate_income<I>(base: I) -> I

--- a/pallets/app-promotion/src/types.rs
+++ b/pallets/app-promotion/src/types.rs
@@ -101,7 +101,7 @@
 
 	fn set_sponsor(sponsor_id: Self::AccountId, contract_id: Self::ContractId) -> DispatchResult;
 
-	fn remove_contract_sponsor(collection_id: Self::ContractId) -> DispatchResult;
+	fn remove_contract_sponsor(contract_id: Self::ContractId) -> DispatchResult;
 
 	fn get_sponsor(contract_id: Self::ContractId)
 		-> Result<Option<Self::AccountId>, DispatchError>;

--- a/pallets/app-promotion/src/weights.rs
+++ b/pallets/app-promotion/src/weights.rs
@@ -3,7 +3,7 @@
 //! Autogenerated weights for pallet_app_promotion
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2022-08-09, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2022-08-30, STEPS: `50`, REPEAT: 80, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
 
 // Executed Command:
@@ -33,108 +33,167 @@
 
 /// Weight functions needed for pallet_app_promotion.
 pub trait WeightInfo {
-	fn on_initialize() -> Weight;
 	fn start_app_promotion() -> Weight;
+	fn stop_app_promotion() -> Weight;
 	fn set_admin_address() -> Weight;
+	fn payout_stakers() -> Weight;
 	fn stake() -> Weight;
 	fn unstake() -> Weight;
 	fn recalculate_stake() -> Weight;
+	fn sponsor_collection() -> Weight;
+	fn stop_sponsoring_collection() -> Weight;
+	fn sponsor_contract() -> Weight;
+	fn stop_sponsoring_contract() -> Weight;
 }
 
 /// Weights for pallet_app_promotion using the Substrate node and recommended hardware.
 pub struct SubstrateWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-	// Storage: Promotion PendingUnstake (r:1 w:0)
-	// Storage: Promotion NextInterestBlock (r:1 w:0)
-	fn on_initialize() -> Weight {
-		(2_705_000 as Weight)
+	// Storage: Promotion StartBlock (r:1 w:1)
+	// Storage: ParachainSystem ValidationData (r:1 w:0)
+	// Storage: Promotion NextInterestBlock (r:0 w:1)
+	fn start_app_promotion() -> Weight {
+		(2_299_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(2 as Weight))
 	}
 	// Storage: Promotion StartBlock (r:1 w:1)
 	// Storage: Promotion NextInterestBlock (r:0 w:1)
-	fn start_app_promotion() -> Weight {
-		(1_436_000 as Weight)
+	fn stop_app_promotion() -> Weight {
+		(1_733_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 			.saturating_add(T::DbWeight::get().writes(2 as Weight))
 	}
 	// Storage: Promotion Admin (r:0 w:1)
 	fn set_admin_address() -> Weight {
-		(516_000 as Weight)
+		(553_000 as Weight)
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Promotion Admin (r:1 w:0)
+	fn payout_stakers() -> Weight {
+		(1_398_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+	}
 	// Storage: System Account (r:1 w:1)
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: ParachainSystem ValidationData (r:1 w:0)
 	// Storage: Promotion Staked (r:1 w:1)
-	// Storage: Promotion TotalStaked (r:1 w:1)
 	fn stake() -> Weight {
-		(10_019_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(5 as Weight))
-			.saturating_add(T::DbWeight::get().writes(4 as Weight))
+		(9_506_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(4 as Weight))
+			.saturating_add(T::DbWeight::get().writes(3 as Weight))
 	}
-	// Storage: System Account (r:1 w:1)
-	// Storage: Balances Locks (r:1 w:1)
-	// Storage: ParachainSystem ValidationData (r:1 w:0)
-	// Storage: Promotion Staked (r:1 w:1)
-	// Storage: Promotion TotalStaked (r:1 w:1)
+	// Storage: System Account (r:1 w:0)
 	fn unstake() -> Weight {
-		(10_619_000 as Weight)
-			.saturating_add(T::DbWeight::get().reads(5 as Weight))
-			.saturating_add(T::DbWeight::get().writes(4 as Weight))
+		(2_529_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
 	}
-	// Storage: System Account (r:2 w:0)
-	// Storage: Promotion Staked (r:0 w:1)
+	// Storage: System Account (r:1 w:0)
 	fn recalculate_stake() -> Weight {
-		(4_932_000 as Weight)
+		(2_203_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn sponsor_collection() -> Weight {
+		(10_882_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn stop_sponsoring_collection() -> Weight {
+		(10_544_000 as Weight)
 			.saturating_add(T::DbWeight::get().reads(2 as Weight))
 			.saturating_add(T::DbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: EvmContractHelpers Sponsoring (r:0 w:1)
+	fn sponsor_contract() -> Weight {
+		(2_163_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: EvmContractHelpers Sponsoring (r:1 w:1)
+	fn stop_sponsoring_contract() -> Weight {
+		(3_511_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
 }
 
 // For backwards compatibility and tests
 impl WeightInfo for () {
-	// Storage: Promotion PendingUnstake (r:1 w:0)
-	// Storage: Promotion NextInterestBlock (r:1 w:0)
-	fn on_initialize() -> Weight {
-		(2_705_000 as Weight)
+	// Storage: Promotion StartBlock (r:1 w:1)
+	// Storage: ParachainSystem ValidationData (r:1 w:0)
+	// Storage: Promotion NextInterestBlock (r:0 w:1)
+	fn start_app_promotion() -> Weight {
+		(2_299_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
 	}
 	// Storage: Promotion StartBlock (r:1 w:1)
 	// Storage: Promotion NextInterestBlock (r:0 w:1)
-	fn start_app_promotion() -> Weight {
-		(1_436_000 as Weight)
+	fn stop_app_promotion() -> Weight {
+		(1_733_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(2 as Weight))
 	}
 	// Storage: Promotion Admin (r:0 w:1)
 	fn set_admin_address() -> Weight {
-		(516_000 as Weight)
+		(553_000 as Weight)
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}
+	// Storage: Promotion Admin (r:1 w:0)
+	fn payout_stakers() -> Weight {
+		(1_398_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+	}
 	// Storage: System Account (r:1 w:1)
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: ParachainSystem ValidationData (r:1 w:0)
 	// Storage: Promotion Staked (r:1 w:1)
-	// Storage: Promotion TotalStaked (r:1 w:1)
 	fn stake() -> Weight {
-		(10_019_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
+		(9_506_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(4 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(3 as Weight))
 	}
-	// Storage: System Account (r:1 w:1)
-	// Storage: Balances Locks (r:1 w:1)
-	// Storage: ParachainSystem ValidationData (r:1 w:0)
-	// Storage: Promotion Staked (r:1 w:1)
-	// Storage: Promotion TotalStaked (r:1 w:1)
+	// Storage: System Account (r:1 w:0)
 	fn unstake() -> Weight {
-		(10_619_000 as Weight)
-			.saturating_add(RocksDbWeight::get().reads(5 as Weight))
-			.saturating_add(RocksDbWeight::get().writes(4 as Weight))
+		(2_529_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
 	}
-	// Storage: System Account (r:2 w:0)
-	// Storage: Promotion Staked (r:0 w:1)
+	// Storage: System Account (r:1 w:0)
 	fn recalculate_stake() -> Weight {
-		(4_932_000 as Weight)
+		(2_203_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn sponsor_collection() -> Weight {
+		(10_882_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: Common CollectionById (r:1 w:1)
+	fn stop_sponsoring_collection() -> Weight {
+		(10_544_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: EvmContractHelpers Sponsoring (r:0 w:1)
+	fn sponsor_contract() -> Weight {
+		(2_163_000 as Weight)
+			.saturating_add(RocksDbWeight::get().reads(1 as Weight))
+			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
+	}
+	// Storage: Promotion Admin (r:1 w:0)
+	// Storage: EvmContractHelpers Sponsoring (r:1 w:1)
+	fn stop_sponsoring_contract() -> Weight {
+		(3_511_000 as Weight)
 			.saturating_add(RocksDbWeight::get().reads(2 as Weight))
 			.saturating_add(RocksDbWeight::get().writes(1 as Weight))
 	}

--- a/pallets/unique/src/benchmarking.rs
+++ b/pallets/unique/src/benchmarking.rs
@@ -46,7 +46,9 @@
 	)?;
 	Ok(<pallet_common::CreatedCollectionCount<T>>::get())
 }
-fn create_nft_collection<T: Config>(owner: T::AccountId) -> Result<CollectionId, DispatchError> {
+pub fn create_nft_collection<T: Config>(
+	owner: T::AccountId,
+) -> Result<CollectionId, DispatchError> {
 	create_collection_helper::<T>(owner, CollectionMode::NFT)
 }
 

--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -98,7 +98,7 @@
 pub mod eth;
 
 #[cfg(feature = "runtime-benchmarks")]
-mod benchmarking;
+pub mod benchmarking;
 pub mod weights;
 use weights::WeightInfo;