git.delta.rocks / unique-network / refs/commits / 1139244e666b

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # App Promotion pallet18//!19//! The pallet implements the mechanics of staking and sponsoring collections/contracts.20//!21//! - [`Config`]22//! - [`Pallet`]23//! - [`Error`]24//! - [`Event`]25//!26//! ## Overview27//! The App Promotion pallet allows fund holders to stake at a certain daily rate of return.28//! The mechanics implemented in the pallet allow it to act as a sponsor for collections / contracts,29//! the list of which is set by the pallet administrator.30//!31//!32//! ## Interface33//!	The pallet provides interfaces for funds, collection/contract operations (see [types] module).3435//!36//! ### Dispatchable Functions37//!	- [`set_admin_address`][`Pallet::set_admin_address`] - sets an address as the the admin.38//! - [`stake`][`Pallet::stake`] - stakes the amount of native tokens.39//! - [`unstake`][`Pallet::unstake`] - unstakes all stakes.40//! - [`sponsor_collection`][`Pallet::sponsor_collection`] - sets the pallet to be the sponsor for the collection.41//! - [`stop_sponsoring_collection`][`Pallet::stop_sponsoring_collection`] - removes the pallet as the sponsor for the collection.42//! - [`sponsor_contract`][`Pallet::sponsor_contract`] - sets the pallet to be the sponsor for the contract.43//! - [`stop_sponsoring_contract`][`Pallet::stop_sponsoring_contract`] - removes the pallet as the sponsor for the contract.44//! - [`payout_stakers`][`Pallet::payout_stakers`] - recalculates interest for the specified number of stakers.45//!4647// #![recursion_limit = "1024"]48#![cfg_attr(not(feature = "std"), no_std)]4950#[cfg(feature = "runtime-benchmarks")]51mod benchmarking;5253pub mod types;54pub mod weights;5556use sp_std::{57	vec::{Vec},58	vec,59	iter::Sum,60	borrow::ToOwned,61	cell::RefCell,62};63use sp_core::H160;64use codec::EncodeLike;65use pallet_balances::BalanceLock;66pub use types::*;6768use up_data_structs::CollectionId;6970use frame_support::{71	dispatch::{DispatchResult},72	traits::{73		Get, LockableCurrency,74		tokens::Balance,75		fungible::{Inspect, InspectFreeze, Mutate, MutateFreeze},76	},77	ensure, BoundedVec,78};7980use weights::WeightInfo;8182pub use pallet::*;83use pallet_evm::account::CrossAccountId;84use sp_runtime::{85	Perbill,86	traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion, Zero},87	ArithmeticError,88};8990pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";9192const PENDING_LIMIT_PER_BLOCK: u32 = 3;9394type BalanceOf<T> =95	<<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;9697#[frame_support::pallet]98pub mod pallet {99	use super::*;100	use frame_support::{101		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId, weights::Weight,102	};103	use frame_system::pallet_prelude::*;104use sp_runtime::DispatchError;105106	#[pallet::config]107	pub trait Config:108		frame_system::Config + pallet_evm::Config + pallet_configuration::Config109	{110		/// Type to interact with the native token111		type Currency: MutateFreeze<Self::AccountId>112			+ Mutate<Self::AccountId> 113			+ ExtendedLockableCurrency<Self::AccountId, Balance = <<Self as Config>::Currency as Inspect<Self::AccountId>>::Balance>;114115		/// Type for interacting with collections116		type CollectionHandler: CollectionHandler<117			AccountId = Self::AccountId,118			CollectionId = CollectionId,119		>;120121		/// Type for interacting with conrtacts122		type ContractHandler: ContractHandler<AccountId = Self::CrossAccountId, ContractId = H160>;123124		/// `AccountId` for treasury125		type TreasuryAccountId: Get<Self::AccountId>;126127		/// The app's pallet id, used for deriving its sovereign account address.128		#[pallet::constant]129		type PalletId: Get<PalletId>;130131		/// Freeze identifier used by the pallet132		#[pallet::constant]133		type FreezeIdentifier: Get<<<Self as Config>::Currency as InspectFreeze<Self::AccountId>>::Id>;134135		/// In relay blocks.136		#[pallet::constant]137		type RecalculationInterval: Get<Self::BlockNumber>;138139		/// In parachain blocks.140		#[pallet::constant]141		type PendingInterval: Get<Self::BlockNumber>;142143		/// Rate of return for interval in blocks defined in `RecalculationInterval`.144		#[pallet::constant]145		type IntervalIncome: Get<Perbill>;146147		/// Decimals for the `Currency`.148		#[pallet::constant]149		type Nominal: Get<BalanceOf<Self>>;150151		/// Weight information for extrinsics in this pallet.152		type WeightInfo: WeightInfo;153154		// The relay block number provider155		type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;156157		/// Events compatible with [`frame_system::Config::Event`].158		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;159	}160161	#[pallet::pallet]162	pub struct Pallet<T>(_);163164	#[pallet::event]165	#[pallet::generate_deposit(pub(super) fn deposit_event)]166	pub enum Event<T: Config> {167		/// Staking recalculation was performed168		///169		/// # Arguments170		/// * AccountId: account of the staker.171		/// * Balance : recalculation base172		/// * Balance : total income173		StakingRecalculation(174			/// An recalculated staker175			T::AccountId,176			/// Base on which interest is calculated177			BalanceOf<T>,178			/// Amount of accrued interest179			BalanceOf<T>,180		),181182		/// Staking was performed183		///184		/// # Arguments185		/// * AccountId: account of the staker186		/// * Balance : staking amount187		Stake(T::AccountId, BalanceOf<T>),188189		/// Unstaking was performed190		///191		/// # Arguments192		/// * AccountId: account of the staker193		/// * Balance : unstaking amount194		Unstake(T::AccountId, BalanceOf<T>),195196		/// The admin was set197		///198		/// # Arguments199		/// * AccountId: account address of the admin200		SetAdmin(T::AccountId),201	}202203	#[pallet::error]204	pub enum Error<T> {205		/// Error due to action requiring admin to be set.206		AdminNotSet,207		/// No permission to perform an action.208		NoPermission,209		/// Insufficient funds to perform an action.210		NotSufficientFunds,211		/// Occurs when a pending unstake cannot be added in this block. PENDING_LIMIT_PER_BLOCK` limits exceeded.212		PendingForBlockOverflow,213		/// The error is due to the fact that the collection/contract must already be sponsored in order to perform the action.214		SponsorNotSet,215		/// Errors caused by insufficient staked balance.216		InsufficientStakedBalance,217		/// Errors caused by incorrect state of a staker in context of the pallet.218		InconsistencyState219	}220221	/// Stores the total staked amount.222	#[pallet::storage]223	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;224225	/// Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.226	#[pallet::storage]227	pub type Admin<T: Config> = StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;228229	/// Stores the amount of tokens staked by account in the blocknumber.230	///231	/// * **Key1** - Staker account.232	/// * **Key2** - Relay block number when the stake was made.233	/// * **(Balance, BlockNumber)** - Balance of the stake.234	/// The number of the relay block in which we must perform the interest recalculation235	#[pallet::storage]236	pub type Staked<T: Config> = StorageNMap<237		Key = (238			Key<Blake2_128Concat, T::AccountId>,239			Key<Twox64Concat, T::BlockNumber>,240		),241		Value = (BalanceOf<T>, T::BlockNumber),242		QueryKind = ValueQuery,243	>;244245	/// Stores number of stake records for an `Account`.246	///247	/// * **Key** - Staker account.248	/// * **Value** - Amount of stakes.249	#[pallet::storage]250	pub type StakesPerAccount<T: Config> =251		StorageMap<_, Blake2_128Concat, T::AccountId, u8, ValueQuery>;252253	/// Pending unstake records for an `Account`.254	///255	/// * **Key** - Staker account.256	/// * **Value** - Amount of stakes.257	#[pallet::storage]258	pub type PendingUnstake<T: Config> = StorageMap<259		_,260		Twox64Concat,261		T::BlockNumber,262		BoundedVec<(T::AccountId, BalanceOf<T>), ConstU32<PENDING_LIMIT_PER_BLOCK>>,263		ValueQuery,264	>;265266	/// Stores a key for record for which the revenue recalculation was performed.267	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.268	#[pallet::storage]269	#[pallet::getter(fn get_next_calculated_record)]270	pub type PreviousCalculatedRecord<T: Config> =271		StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;272273	// #[pallet::storage]274	// pub(crate) type UpgradedToFreezes<T: Config> =275	// 	StorageValue<Value = bool, QueryKind = ValueQuery>;276277	#[pallet::hooks]278	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {279		/// Block overflow is impossible due to the fact that the unstake algorithm in on_initialize280		/// implies the execution of a strictly limited number of relatively lightweight operations.281		/// A separate benchmark has been implemented to scale the weight depending on the number of pendings.282		fn on_initialize(current_block_number: T::BlockNumber) -> Weight283		where284			<T as frame_system::Config>::BlockNumber: From<u32>,285		{286			let block_pending = PendingUnstake::<T>::take(current_block_number);287			let counter = block_pending.len() as u32;288289			if !block_pending.is_empty() {290				block_pending.into_iter().for_each(|(staker, amount)| {291					Self::get_frozen_balance(&staker).map(|b| {292						let new_state = b.checked_sub(&amount).unwrap_or_default();293						Self::set_freeze_unchecked(&staker, new_state);294					});295				});296			}297298			<T as Config>::WeightInfo::on_initialize(counter)299		}300301		// fn on_runtime_upgrade() -> Weight {302		// 	use scale_info::prelude::collections::HashSet;303		// 	let mut consumed_weight = Weight::zero();304		// 	let mut add_weight = |reads, writes, weight| {305		// 		consumed_weight += T::DbWeight::get().reads_writes(reads, writes);306		// 		consumed_weight += weight;307		// 	};308309		// 	let mut stakes_unstakes = vec![];310311		// 	if <UpgradedToFreezes<T>>::get() {312		// 		add_weight(1, 0, Weight::zero());313		// 		return consumed_weight;314		// 	} else {315		// 		add_weight(1, 1, Weight::zero());316		// 		<UpgradedToFreezes<T>>::set(true);317		// 	}318		// 	<Staked<T>>::iter_keys().for_each(|(staker_id, _)| {319		// 		add_weight(1, 0, Weight::zero());320		// 		stakes_unstakes.push(staker_id);321		// 	});322323		// 	<PendingUnstake<T>>::iter().for_each(|(_, v)| {324		// 		add_weight(1, 0, Weight::zero());325		// 		v.into_iter().for_each(|(staker, _)| {326		// 			stakes_unstakes.push(staker);327		// 		});328		// 	});329330		// 	// filter duplicated id.331		// 	stakes_unstakes = stakes_unstakes332		// 		.into_iter()333		// 		.map(|key| key)334		// 		.collect::<HashSet<_>>()335		// 		.into_iter()336		// 		.collect();337338		// 	stakes_unstakes339		// 		.map(|a| (a, <Pallet<T>>::get_locked_balance(&a).amount))340		// 		.for_each(|(staker, amount)| {341		// 			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(342		// 				LOCK_IDENTIFIER,343		// 				&staker,344		// 			);345		// 			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::set_freeze(346		// 				&<T as Config>::FreezeIdentifier::get(),347		// 				&staker,348		// 				amount,349		// 			);350		// 			add_weight(1, 2, Weight::zero())351		// 		});352353		// 	consumed_weight354		// }355356		// #[cfg(feature = "try-runtime")]357		// fn pre_upgrade() -> Result<Vec<u8>, &'static str> {358		// 	use sp_std::collections::btree_map::BTreeMap;359		// 	if <UpgradedToFreezes<T>>::get() {360		// 		return Ok(Default::default());361		// 	}362		// 	// Staker -> (total (stakes and unstakes) locked by promotion);363		// 	let mut pre_state: BTreeMap<T::AccountId, BalanceOf<T>> = BTreeMap::new();364365		// 	<Staked<T>>::iter().for_each(|((staker, _), (amount, _))| {366		// 		if let Some(locked_balance) = pre_state.get_mut(&staker) {367		// 			*locked_balance += amount;368		// 		} else {369		// 			pre_state.insert(staker, amount);370		// 		}371		// 	});372373		// 	<PendingUnstake<T>>::iter().for_each(|(_, v)| {374		// 		v.into_iter().for_each(|(staker, amount)| {375		// 			if let Some(locked_balance) = pre_state.get_mut(&staker) {376		// 				*locked_balance += amount;377		// 			} else {378		// 				pre_state.insert(staker, amount);379		// 			}380		// 		})381		// 	});382383		// 	Ok(pre_state.encode())384		// }385386		// #[cfg(feature = "try-runtime")]387		// fn post_upgrade(pre_state: Vec<u8>) -> Result<(), &'static str> {388		// 	use sp_std::collections::btree_map::BTreeMap;389390		// 	if <UpgradedToFreezes<T>>::get() {391		// 		return Ok(());392		// 	}393394		// 	let mut is_ok = true;395396		// 	let pre_state: BTreeMap<T::AccountId, BalanceOf<T>> =397		// 		Decode::decode(&mut &pre_state[..]).map_err(|_| "failed to decode pre_state")?;398		// 	for (staker, frozen_by_promo) in pre_state.into_iter() {399		// 		let storage_freeze_state = <<T as Config>::Currency as InspectFreeze<400		// 			T::AccountId,401		// 		>>::balance_frozen(402		// 			&<T as Config>::FreezeIdentifier::get(), staker403		// 		);404		// 		if storage_freeze_state != frozen_by_promo {405		// 			is_ok = false;406		// 			log::error!(407		// 						"Incorrect frozen balance for {:?}. New balance: {:?}. Before runtime upgrade: locked by promo - {:?}",408		// 						staker, storage_freeze_state, frozen_by_promo409		// 					);410		// 		}411412		// 		if !<Pallet<T>>::get_locked_balance(&staker).amount.is_zero() {413		// 			is_ok = false;414		// 			log::error!(415		// 				"Incorrect(non-zero) locked by app promo balance for {:?}",416		// 				staker417		// 			);418		// 		}419		// 	}420421		// 	if is_ok {422		// 		Ok(())423		// 	} else {424		// 		Err("Incorrect balance for some of stakers... See logs")425		// 	}426		// }427	}428429	#[pallet::call]430	impl<T: Config> Pallet<T>431	where432		T::BlockNumber: From<u32> + Into<u32>,433		<<T as Config>::Currency as Inspect<T::AccountId>>::Balance: Sum + From<u128>,434	{435		/// Sets an address as the the admin.436		///437		/// # Permissions438		///439		/// * Sudo440		///441		/// # Arguments442		///443		/// * `admin`: account of the new admin.444		#[pallet::call_index(0)]445		#[pallet::weight(<T as Config>::WeightInfo::set_admin_address())]446		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {447			ensure_root(origin)?;448449			<Admin<T>>::set(Some(admin.as_sub().to_owned()));450451			Self::deposit_event(Event::SetAdmin(admin.as_sub().to_owned()));452453			Ok(())454		}455456		/// Stakes the amount of native tokens.457		/// Sets `amount` to the locked state.458		/// The maximum number of stakes for a staker is 10.459		///460		/// # Arguments461		///462		/// * `amount`: in native tokens.463		#[pallet::call_index(1)]464		#[pallet::weight(<T as Config>::WeightInfo::stake())]465		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {466			let staker_id = ensure_signed(staker)?;467468			ensure!(469				StakesPerAccount::<T>::get(&staker_id) < 10,470				Error::<T>::NoPermission471			);472473			ensure!(474				amount >= <BalanceOf<T>>::from(100u128) * T::Nominal::get(),475				ArithmeticError::Underflow476			);477			let config = <PalletConfiguration<T>>::get();478479			let balance = <<T as Config>::Currency as Inspect<T::AccountId>>::balance(&staker_id);480481			// checks that we can freeze `amount` on the `staker` account.482			ensure!(483				amount484					<= match Self::get_frozen_balance(&staker_id) {485						Some(frozen_by_pallet) => balance486							.checked_sub(&frozen_by_pallet)487							.ok_or(ArithmeticError::Underflow)?,488						None => balance,489					},490				ArithmeticError::Underflow491			);492493			Self::add_freeze_balance(&staker_id, amount)?;494495			let block_number = T::RelayBlockNumberProvider::current_block_number();496497			// Calculation of the number of recalculation periods,498			// after how much the first interest calculation should be performed for the stake499			let recalculate_after_interval: T::BlockNumber =500				if block_number % config.recalculation_interval == 0u32.into() {501					1u32.into()502				} else {503					2u32.into()504				};505506			// Сalculation of the number of the relay block507			// in which it is necessary to accrue remuneration for the stake.508			let recalc_block = (block_number / config.recalculation_interval509				+ recalculate_after_interval)510				* config.recalculation_interval;511512			<Staked<T>>::insert((&staker_id, block_number), {513				let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));514				balance_and_recalc_block.0 = balance_and_recalc_block515					.0516					.checked_add(&amount)517					.ok_or(ArithmeticError::Overflow)?;518				balance_and_recalc_block.1 = recalc_block;519				balance_and_recalc_block520			});521522			<TotalStaked<T>>::set(523				<TotalStaked<T>>::get()524					.checked_add(&amount)525					.ok_or(ArithmeticError::Overflow)?,526			);527528			StakesPerAccount::<T>::mutate(&staker_id, |stakes| *stakes += 1);529530			Self::deposit_event(Event::Stake(staker_id, amount));531532			Ok(())533		}534535		/// Unstakes all stakes.536		/// After the end of `PendingInterval` this sum becomes completely537		/// free for further use.538		#[pallet::call_index(2)]539		#[pallet::weight(<T as Config>::WeightInfo::unstake_all())]540		pub fn unstake_all(staker: OriginFor<T>) -> DispatchResult {541			let staker_id = ensure_signed(staker)?;542543			Self::unstake_all_internal(staker_id)544		}545546		/// Unstakes the amount of balance for the staker.547		/// After the end of `PendingInterval` this sum becomes completely548		/// free for further use.549		///550		///  # Arguments551		///552		/// * `staker`: staker account.553		/// * `amount`: amount of unstaked funds.554		#[pallet::call_index(8)]555		#[pallet::weight(<T as Config>::WeightInfo::unstake_partial())]556		pub fn unstake_partial(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {557			let staker_id = ensure_signed(staker)?;558559			Self::unstake_partial_internal(staker_id, amount)560		}561562		/// Sets the pallet to be the sponsor for the collection.563		///564		/// # Permissions565		///566		/// * Pallet admin567		///568		/// # Arguments569		///570		/// * `collection_id`: ID of the collection that will be sponsored by `pallet_id`571		#[pallet::call_index(3)]572		#[pallet::weight(<T as Config>::WeightInfo::sponsor_collection())]573		pub fn sponsor_collection(574			admin: OriginFor<T>,575			collection_id: CollectionId,576		) -> DispatchResult {577			let admin_id = ensure_signed(admin)?;578			ensure!(579				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,580				Error::<T>::NoPermission581			);582583			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)584		}585586		/// Removes the pallet as the sponsor for the collection.587		/// Returns [`NoPermission`][`Error::NoPermission`]588		/// if the pallet wasn't the sponsor.589		///590		/// # Permissions591		///592		/// * Pallet admin593		///594		/// # Arguments595		///596		/// * `collection_id`: ID of the collection that is sponsored by `pallet_id`597		#[pallet::call_index(4)]598		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_collection())]599		pub fn stop_sponsoring_collection(600			admin: OriginFor<T>,601			collection_id: CollectionId,602		) -> DispatchResult {603			let admin_id = ensure_signed(admin)?;604605			ensure!(606				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,607				Error::<T>::NoPermission608			);609610			ensure!(611				T::CollectionHandler::sponsor(collection_id)?.ok_or(<Error<T>>::SponsorNotSet)?612					== Self::account_id(),613				<Error<T>>::NoPermission614			);615			T::CollectionHandler::remove_collection_sponsor(collection_id)616		}617618		/// Sets the pallet to be the sponsor for the contract.619		///620		/// # Permissions621		///622		/// * Pallet admin623		///624		/// # Arguments625		///626		/// * `contract_id`: the contract address that will be sponsored by `pallet_id`627		#[pallet::call_index(5)]628		#[pallet::weight(<T as Config>::WeightInfo::sponsor_contract())]629		pub fn sponsor_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {630			let admin_id = ensure_signed(admin)?;631632			ensure!(633				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,634				Error::<T>::NoPermission635			);636637			T::ContractHandler::set_sponsor(638				T::CrossAccountId::from_sub(Self::account_id()),639				contract_id,640			)641		}642643		/// Removes the pallet as the sponsor for the contract.644		/// Returns [`NoPermission`][`Error::NoPermission`]645		/// if the pallet wasn't the sponsor.646		///647		/// # Permissions648		///649		/// * Pallet admin650		///651		/// # Arguments652		///653		/// * `contract_id`: the contract address that is sponsored by `pallet_id`654		#[pallet::call_index(6)]655		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_contract())]656		pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {657			let admin_id = ensure_signed(admin)?;658659			ensure!(660				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,661				Error::<T>::NoPermission662			);663664			ensure!(665				T::ContractHandler::sponsor(contract_id)?666					.ok_or(<Error<T>>::SponsorNotSet)?667					.as_sub() == &Self::account_id(),668				<Error<T>>::NoPermission669			);670			T::ContractHandler::remove_contract_sponsor(contract_id)671		}672673		/// Recalculates interest for the specified number of stakers.674		/// If all stakers are not recalculated, the next call of the extrinsic675		/// will continue the recalculation, from those stakers for whom this676		/// was not perform in last call.677		///678		/// # Permissions679		///680		/// * Pallet admin681		///682		/// # Arguments683		///684		/// * `stakers_number`: the number of stakers for which recalculation will be performed685		#[pallet::call_index(7)]686		#[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]687		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {688			let admin_id = ensure_signed(admin)?;689690			ensure!(691				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,692				Error::<T>::NoPermission693			);694			let config = <PalletConfiguration<T>>::get();695696			let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);697698			ensure!(699				stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,700				Error::<T>::NoPermission701			);702703			// calculate the number of the current recalculation block,704			// this is necessary in order to understand which stakers we should calculate interest705			let current_recalc_block = Self::get_current_recalc_block(706				T::RelayBlockNumberProvider::current_block_number(),707				&config,708			);709710			// calculate the number of the next recalculation block,711			// this value is set for the stakers to whom the recalculation will be performed712			let next_recalc_block = current_recalc_block + config.recalculation_interval;713714			let mut storage_iterator = Self::get_next_calculated_key()715				.map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));716717			PreviousCalculatedRecord::<T>::set(None);718719			{720				// Address handled in the last payout loop iteration (below)721				let last_id = RefCell::new(None);722				// Block number (as a part of the key) for which calculation was performed in the last payout loop iteration723				let mut last_staked_calculated_block = Default::default();724				// Reward balance for the address in the iteration725				let income_acc = RefCell::new(BalanceOf::<T>::default());726				// Staked balance for the address in the iteration (before stake is recalculated)727				let amount_acc = RefCell::new(BalanceOf::<T>::default());728729				// This closure is used to finalize handling single staker address in each of the two conditions: (1) when we break out of the payout730				// loop because we reached the number of stakes for rewarding, (2) When all stakes by the single address are handled and the payout731				// loop switches to handling the next staker address:732				//   1. Transfer full reward amount to the payee733				//   2. Lock the reward in staking lock734				//   3. Update TotalStaked amount735				//   4. Issue StakingRecalculation event736				let flush_stake = || -> DispatchResult {737					if let Some(last_id) = &*last_id.borrow() {738						if !income_acc.borrow().is_zero() {739							<<T as Config>::Currency as Mutate<T::AccountId>>::transfer(740								&T::TreasuryAccountId::get(),741								last_id,742								*income_acc.borrow(),743								frame_support::traits::tokens::Preservation::Protect,744							)?;745746							Self::add_freeze_balance(last_id, *income_acc.borrow())?;747							<TotalStaked<T>>::try_mutate(|staked| -> DispatchResult {748								*staked = staked749									.checked_add(&*income_acc.borrow())750									.ok_or(ArithmeticError::Overflow)?;751								Ok(())752							})?;753754							Self::deposit_event(Event::StakingRecalculation(755								last_id.clone(),756								*amount_acc.borrow(),757								*income_acc.borrow(),758							));759						}760761						*income_acc.borrow_mut() = BalanceOf::<T>::default();762						*amount_acc.borrow_mut() = BalanceOf::<T>::default();763					}764					Ok(())765				};766767				// Reward payment loop. Should loop for no more than config.max_stakers_per_calculation768				// iterations in one extrinsic call769				//770				// stakers_number - keeps the remaining number of iterations (staker addresses to handle)771				// next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out772				// income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)773				while let Some((774					(current_id, staked_block),775					(amount, next_recalc_block_for_stake),776				)) = storage_iterator.next()777				{778					// last_id is not equal current_id when we switch to handling a new staker address779					// or just start handling the very first address. In the latter case last_id will be None and780					// flush_stake will do nothing781					if last_id.borrow().as_ref() != Some(&current_id) {782						if stakers_number > 0 {783							flush_stake()?;784							*last_id.borrow_mut() = Some(current_id.clone());785							stakers_number -= 1;786						}787						// Break out if we reached the address limit788						else {789							if let Some(staker) = &*last_id.borrow() {790								// Save the last calculated record to pick up in the next extrinsic call791								PreviousCalculatedRecord::<T>::set(Some((792									staker.clone(),793									last_staked_calculated_block,794								)));795							}796							break;797						};798					};799800					// Increase accumulated reward for current address and update current staking record, i.e. (address, staked_block) -> amount801					if current_recalc_block >= next_recalc_block_for_stake {802						*amount_acc.borrow_mut() += amount;803						Self::recalculate_and_insert_stake(804							&current_id,805							staked_block,806							next_recalc_block,807							amount,808							((current_recalc_block - next_recalc_block_for_stake)809								/ config.recalculation_interval)810								.into() + 1,811							&mut *income_acc.borrow_mut(),812						);813					}814					last_staked_calculated_block = staked_block;815				}816				flush_stake()?;817			}818819			Ok(())820		}821822		///  Migrates lock state into freeze one823		///824		///  # Arguments825		///826		/// * `origin`: Must be `Signed`.827		/// * `stakers`: Accounts to be upgraded.828		#[pallet::call_index(9)]829		#[pallet::weight(T::DbWeight::get().reads_writes(2, 2) * stakers.len() as u64)]830		pub fn upgrade_accounts(831			origin: OriginFor<T>,832			stakers: Vec<T::AccountId>,833		) -> DispatchResult {834			ensure_signed(origin)?;835836			stakers.into_iter().try_for_each(|s| -> Result<_, DispatchError> {837				if let Some(lock) = Self::get_locked_balance(&s) {838					839					if let Some(_) = Self::get_frozen_balance(&s) {840						return Err(Error::<T>::InconsistencyState.into())841					}842					843					<<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(844						LOCK_IDENTIFIER,845						&s,846					);847848					Self::set_freeze_unchecked(&s, lock.amount);849					Ok(())850				} else {851					Ok(())852				}853			})?;854			855			Ok(())856		}857	}858}859860impl<T: Config> Pallet<T> {861	/// The account address of the app promotion pot.862	///863	/// This actually does computation. If you need to keep using it, then make sure you cache the864	/// value and only call this once.865	pub fn account_id() -> T::AccountId {866		T::PalletId::get().into_account_truncating()867	}868869	/// Unstakes the balance for the staker.870	///871	/// - `staker`: staker account.872	/// - `amount`: amount of unstaked funds.873	fn unstake_partial_internal(874		staker_id: T::AccountId,875		unstaked_balance: BalanceOf<T>,876	) -> DispatchResult {877		if unstaked_balance == Default::default() {878			return Ok(());879		}880881		let config = <PalletConfiguration<T>>::get();882883		// calculate block number where the sum would be free884		let unpending_block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;885886		let mut pendings = <PendingUnstake<T>>::get(unpending_block);887888		// checks that we can do unstake in the block889		ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);890891		let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();892893		let total_staked = stakes894			.iter()895			.fold(<BalanceOf<T>>::default(), |acc, (_, (balance, _))| {896				acc + *balance897			});898899		ensure!(900			unstaked_balance <= total_staked,901			<Error<T>>::InsufficientStakedBalance902		);903904		<TotalStaked<T>>::set(905			<TotalStaked<T>>::get()906				.checked_sub(&unstaked_balance)907				.ok_or(ArithmeticError::Underflow)?,908		);909910		stakes.sort_by_key(|(block, _)| *block);911912		let mut acc_amount = unstaked_balance;913		let mut will_deleted_stakes_count = 0u8;914915		let changed_stakes = stakes916			.into_iter()917			.map_while(|(block, (balance_per_block, _))| {918				if acc_amount == <BalanceOf<T>>::default() {919					return None;920				}921				if acc_amount < balance_per_block {922					let res = (block, balance_per_block - acc_amount);923					acc_amount = <BalanceOf<T>>::default();924					return Some(res);925				} else {926					acc_amount -= balance_per_block;927					will_deleted_stakes_count += 1;928					return Some((block, <BalanceOf<T>>::default()));929				}930			})931			.collect::<Vec<_>>();932933		pendings934			.try_push((staker_id.clone(), unstaked_balance))935			.map_err(|_| Error::<T>::PendingForBlockOverflow)?;936937		StakesPerAccount::<T>::try_mutate(&staker_id, |stakes| -> DispatchResult {938			*stakes = stakes939				.checked_sub(will_deleted_stakes_count)940				.ok_or(ArithmeticError::Underflow)?;941			Ok(())942		})?;943944		changed_stakes945			.into_iter()946			.for_each(|(staked_block, current_stake_state)| {947				if current_stake_state == Default::default() {948					<Staked<T>>::remove((&staker_id, staked_block));949				} else {950					<Staked<T>>::mutate((&staker_id, staked_block), |(old_stake_state, _)| {951						*old_stake_state = current_stake_state952					});953				}954			});955956		<PendingUnstake<T>>::insert(unpending_block, pendings);957958		Self::deposit_event(Event::Unstake(staker_id, unstaked_balance));959960		Ok(())961	}962963	/// Adds the balance to locked by the pallet.964	///965	/// - `staker`: staker account.966	/// - `amount`: amount of added locked funds.967	// fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {968	// 	Self::get_locked_balance(staker)969	// 		.map_or(<BalanceOf<T>>::default(), |l| l.amount)970	// 		.checked_add(&amount)971	// 		.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))972	// 		.ok_or(ArithmeticError::Overflow.into())973	// }974975	/// Adds the balance to frozen by the pallet.976	///977	/// - `staker`: staker account.978	/// - `amount`: amount of added frozen funds.979	fn add_freeze_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {980		Self::get_frozen_balance(staker)981			.unwrap_or_default()982			.checked_add(&amount)983			.map(|freeze| Self::set_freeze_unchecked(staker, freeze))984			.ok_or(ArithmeticError::Overflow.into())985	}986987	/// Sets the new state of a balance locked by the pallet.988	///989	/// - `staker`: staker account.990	/// - `amount`: amount of locked funds.991	// fn set_lock_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {992	// 	if amount.is_zero() {993	// 		<<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(994	// 			LOCK_IDENTIFIER,995	// 			&staker,996	// 		);997	// 	} else {998	// 		<<T as Config>::Currency as LockableCurrency<T::AccountId>>::set_lock(999	// 			LOCK_IDENTIFIER,1000	// 			staker,1001	// 			amount,1002	// 			WithdrawReasons::all(),1003	// 		)1004	// 	}1005	// }10061007	/// Sets the new state of a balance frozen by the pallet.1008	///1009	/// - `staker`: staker account.1010	/// - `amount`: amount of frozen funds.1011	fn set_freeze_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {1012		if amount.is_zero() {1013			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::thaw(1014				&T::FreezeIdentifier::get(),1015				&staker,1016			);1017		} else {1018			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::set_freeze(1019				&T::FreezeIdentifier::get(),1020				staker,1021				amount,1022			);1023		}1024	}10251026	/// Returns the balance locked by the pallet for the staker.1027	///1028	/// - `staker`: staker account.1029	pub fn get_locked_balance(1030		staker: impl EncodeLike<T::AccountId>,1031	) -> Option<BalanceLock<BalanceOf<T>>> {1032		<<T as Config>::Currency as ExtendedLockableCurrency<T::AccountId>>::locks(staker)1033			.into_iter()1034			.find(|l| l.id == LOCK_IDENTIFIER)1035	}10361037	/// Returns the balance frozen by the pallet for the staker.1038	///1039	/// - `staker`: staker account.1040	pub fn get_frozen_balance(staker: &T::AccountId) -> Option<BalanceOf<T>> {1041		let res = <<T as Config>::Currency as InspectFreeze<T::AccountId>>::balance_frozen(1042			&T::FreezeIdentifier::get(),1043			staker,1044		);10451046		if res == Zero::zero() {1047			None1048		} else {1049			Some(res)1050		}1051	}10521053	/// Returns the total staked balance for the staker.1054	///1055	/// - `staker`: staker account.1056	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {1057		let staked = Staked::<T>::iter_prefix((staker,))1058			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {1059				acc + amount1060			});1061		if staked != <BalanceOf<T>>::default() {1062			Some(staked)1063		} else {1064			None1065		}1066	}10671068	/// Returns all relay block numbers when stake was made,1069	/// the amount of the stake.1070	///1071	/// - `staker`: staker account.1072	pub fn total_staked_by_id_per_block(1073		staker: impl EncodeLike<T::AccountId>,1074	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {1075		let mut staked = Staked::<T>::iter_prefix((staker,))1076			.map(|(block, (amount, _))| (block, amount))1077			.collect::<Vec<_>>();1078		staked.sort_by_key(|(block, _)| *block);1079		if !staked.is_empty() {1080			Some(staked)1081		} else {1082			None1083		}1084	}10851086	/// Returns the total staked balance for the staker.1087	/// If `staker` is `None`, returns the total amount staked.1088	/// - `staker`: staker account.1089	pub fn cross_id_total_staked(staker: Option<T::CrossAccountId>) -> Option<BalanceOf<T>> {1090		staker.map_or(Some(<TotalStaked<T>>::get()), |s| {1091			Self::total_staked_by_id(s.as_sub())1092		})1093	}10941095	/// Returns all relay block numbers when stake was made,1096	/// the amount of the stake.1097	///1098	/// - `staker`: staker account.1099	pub fn cross_id_total_staked_per_block(1100		staker: T::CrossAccountId,1101	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1102		Self::total_staked_by_id_per_block(staker.as_sub()).unwrap_or_default()1103	}11041105	fn recalculate_and_insert_stake(1106		staker: &T::AccountId,1107		staked_block: T::BlockNumber,1108		next_recalc_block: T::BlockNumber,1109		base: BalanceOf<T>,1110		iters: u32,1111		income_acc: &mut BalanceOf<T>,1112	) {1113		let income = Self::calculate_income(base, iters);11141115		base.checked_add(&income).map(|res| {1116			<Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));1117			*income_acc += income;1118		});1119	}11201121	fn calculate_income<I>(base: I, iters: u32) -> I1122	where1123		I: EncodeLike<BalanceOf<T>> + Balance,1124	{1125		let config = <PalletConfiguration<T>>::get();1126		let mut income = base;11271128		(0..iters).for_each(|_| income += config.interval_income * income);11291130		income - base1131	}11321133	/// Get relay block number rounded down to multiples of config.recalculation_interval.1134	/// We need it to reward stakers in integer parts of recalculation_interval1135	fn get_current_recalc_block(1136		current_relay_block: T::BlockNumber,1137		config: &PalletConfiguration<T>,1138	) -> T::BlockNumber {1139		(current_relay_block / config.recalculation_interval) * config.recalculation_interval1140	}11411142	fn get_next_calculated_key() -> Option<Vec<u8>> {1143		Self::get_next_calculated_record().map(|key| Staked::<T>::hashed_key_for(key))1144	}1145}11461147impl<T: Config> Pallet<T>1148where1149	<<T as Config>::Currency as Inspect<T::AccountId>>::Balance: Sum,1150{1151	/// Returns the amount reserved by the pending.1152	/// If `staker` is `None`, returns the total pending.1153	///1154	/// -`staker`: staker account.1155	///1156	/// Since user funds are not transferred anywhere by staking, overflow protection is provided1157	/// at the level of the associated type `Balance` of `Currency` trait. In order to overflow,1158	/// the staker must have more funds on his account than the maximum set for `Balance` type.1159	pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {1160		staker.map_or(1161			PendingUnstake::<T>::iter_values()1162				.flat_map(|pendings| pendings.into_iter().map(|(_, amount)| amount))1163				.sum(),1164			|s| {1165				PendingUnstake::<T>::iter_values()1166					.flatten()1167					.filter_map(|(id, amount)| {1168						if id == *s.as_sub() {1169							Some(amount)1170						} else {1171							None1172						}1173					})1174					.sum()1175			},1176		)1177	}11781179	/// Returns all parachain block numbers when unreserve is expected,1180	/// the amount of the unreserved funds.1181	///1182	/// - `staker`: staker account.1183	pub fn cross_id_pending_unstake_per_block(1184		staker: T::CrossAccountId,1185	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1186		let mut unsorted_res = vec![];1187		PendingUnstake::<T>::iter().for_each(|(block, pendings)| {1188			pendings.into_iter().for_each(|(id, amount)| {1189				if id == *staker.as_sub() {1190					unsorted_res.push((block, amount));1191				};1192			})1193		});11941195		unsorted_res.sort_by_key(|(block, _)| *block);1196		unsorted_res1197	}11981199	fn unstake_all_internal(staker_id: T::AccountId) -> DispatchResult {1200		let config = <PalletConfiguration<T>>::get();12011202		// calculate block number where the sum would be free1203		let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;12041205		let mut pendings = <PendingUnstake<T>>::get(block);12061207		// checks that we can do unstake in the block1208		ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);12091210		let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))1211			.map(|(_, (amount, _))| amount)1212			.sum();12131214		if total_staked.is_zero() {1215			return Ok(());1216		}12171218		pendings1219			.try_push((staker_id.clone(), total_staked))1220			.map_err(|_| Error::<T>::PendingForBlockOverflow)?;12211222		<PendingUnstake<T>>::insert(block, pendings);12231224		TotalStaked::<T>::set(1225			TotalStaked::<T>::get()1226				.checked_sub(&total_staked)1227				.ok_or(ArithmeticError::Underflow)?,1228		);12291230		StakesPerAccount::<T>::remove(&staker_id);12311232		Self::deposit_event(Event::Unstake(staker_id, total_staked));12331234		Ok(())1235	}1236}