git.delta.rocks / unique-network / refs/commits / 59a9de8ca347

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		Currency, Get, LockableCurrency, WithdrawReasons, tokens::Balance, ExistenceRequirement,74	},75	ensure, BoundedVec,76};7778use weights::WeightInfo;7980pub use pallet::*;81use pallet_evm::account::CrossAccountId;82use sp_runtime::{83	Perbill,84	traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion, Zero},85	ArithmeticError,86};8788pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";8990const PENDING_LIMIT_PER_BLOCK: u32 = 3;9192type BalanceOf<T> =93	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;9495#[frame_support::pallet]96pub mod pallet {97	use super::*;98	use frame_support::{99		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId,100		traits::ReservableCurrency, weights::Weight,101	};102	use frame_system::pallet_prelude::*;103104	#[pallet::config]105	pub trait Config:106		frame_system::Config + pallet_evm::Config + pallet_configuration::Config107	{108		/// Type to interact with the native token109		type Currency: ExtendedLockableCurrency<Self::AccountId>110			+ ReservableCurrency<Self::AccountId>;111112		/// Type for interacting with collections113		type CollectionHandler: CollectionHandler<114			AccountId = Self::AccountId,115			CollectionId = CollectionId,116		>;117118		/// Type for interacting with conrtacts119		type ContractHandler: ContractHandler<AccountId = Self::CrossAccountId, ContractId = H160>;120121		/// `AccountId` for treasury122		type TreasuryAccountId: Get<Self::AccountId>;123124		/// The app's pallet id, used for deriving its sovereign account address.125		#[pallet::constant]126		type PalletId: Get<PalletId>;127128		/// In relay blocks.129		#[pallet::constant]130		type RecalculationInterval: Get<Self::BlockNumber>;131132		/// In parachain blocks.133		#[pallet::constant]134		type PendingInterval: Get<Self::BlockNumber>;135136		/// Rate of return for interval in blocks defined in `RecalculationInterval`.137		#[pallet::constant]138		type IntervalIncome: Get<Perbill>;139140		/// Decimals for the `Currency`.141		#[pallet::constant]142		type Nominal: Get<BalanceOf<Self>>;143144		/// Weight information for extrinsics in this pallet.145		type WeightInfo: WeightInfo;146147		// The relay block number provider148		type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;149150		/// Events compatible with [`frame_system::Config::Event`].151		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;152	}153154	#[pallet::pallet]155	#[pallet::generate_store(pub(super) trait Store)]156	pub struct Pallet<T>(_);157158	#[pallet::event]159	#[pallet::generate_deposit(pub(super) fn deposit_event)]160	pub enum Event<T: Config> {161		/// Staking recalculation was performed162		///163		/// # Arguments164		/// * AccountId: account of the staker.165		/// * Balance : recalculation base166		/// * Balance : total income167		StakingRecalculation(168			/// An recalculated staker169			T::AccountId,170			/// Base on which interest is calculated171			BalanceOf<T>,172			/// Amount of accrued interest173			BalanceOf<T>,174		),175176		/// Staking was performed177		///178		/// # Arguments179		/// * AccountId: account of the staker180		/// * Balance : staking amount181		Stake(T::AccountId, BalanceOf<T>),182183		/// Unstaking was performed184		///185		/// # Arguments186		/// * AccountId: account of the staker187		/// * Balance : unstaking amount188		Unstake(T::AccountId, BalanceOf<T>),189190		/// The admin was set191		///192		/// # Arguments193		/// * AccountId: account address of the admin194		SetAdmin(T::AccountId),195	}196197	#[pallet::error]198	pub enum Error<T> {199		/// Error due to action requiring admin to be set.200		AdminNotSet,201		/// No permission to perform an action.202		NoPermission,203		/// Insufficient funds to perform an action.204		NotSufficientFunds,205		/// Occurs when a pending unstake cannot be added in this block. PENDING_LIMIT_PER_BLOCK` limits exceeded.206		PendingForBlockOverflow,207		/// The error is due to the fact that the collection/contract must already be sponsored in order to perform the action.208		SponsorNotSet,209		/// Errors caused by incorrect actions with a locked balance.210		IncorrectLockedBalanceOperation,211		/// Errors caused by insufficient staked balance.212		InsufficientStakedBalance,213	}214215	/// Stores the total staked amount.216	#[pallet::storage]217	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;218219	/// Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.220	#[pallet::storage]221	pub type Admin<T: Config> = StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;222223	/// Stores the amount of tokens staked by account in the blocknumber.224	///225	/// * **Key1** - Staker account.226	/// * **Key2** - Relay block number when the stake was made.227	/// * **(Balance, BlockNumber)** - Balance of the stake.228	/// The number of the relay block in which we must perform the interest recalculation229	#[pallet::storage]230	pub type Staked<T: Config> = StorageNMap<231		Key = (232			Key<Blake2_128Concat, T::AccountId>,233			Key<Twox64Concat, T::BlockNumber>,234		),235		Value = (BalanceOf<T>, T::BlockNumber),236		QueryKind = ValueQuery,237	>;238239	/// Stores number of stake records for an `Account`.240	///241	/// * **Key** - Staker account.242	/// * **Value** - Amount of stakes.243	#[pallet::storage]244	pub type StakesPerAccount<T: Config> =245		StorageMap<_, Blake2_128Concat, T::AccountId, u8, ValueQuery>;246247	/// Pending unstake records for an `Account`.248	///249	/// * **Key** - Staker account.250	/// * **Value** - Amount of stakes.251	#[pallet::storage]252	pub type PendingUnstake<T: Config> = StorageMap<253		_,254		Twox64Concat,255		T::BlockNumber,256		BoundedVec<(T::AccountId, BalanceOf<T>), ConstU32<PENDING_LIMIT_PER_BLOCK>>,257		ValueQuery,258	>;259260	/// Stores a key for record for which the revenue recalculation was performed.261	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.262	#[pallet::storage]263	#[pallet::getter(fn get_next_calculated_record)]264	pub type PreviousCalculatedRecord<T: Config> =265		StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;266267	#[pallet::storage]268	pub(crate) type UpgradedToReserves<T: Config> =269		StorageValue<Value = bool, QueryKind = ValueQuery>;270271	#[pallet::hooks]272	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {273		/// Block overflow is impossible due to the fact that the unstake algorithm in on_initialize274		/// implies the execution of a strictly limited number of relatively lightweight operations.275		/// A separate benchmark has been implemented to scale the weight depending on the number of pendings.276		fn on_initialize(current_block_number: T::BlockNumber) -> Weight277		where278			<T as frame_system::Config>::BlockNumber: From<u32>,279		{280			let block_pending = PendingUnstake::<T>::take(current_block_number);281			let counter = block_pending.len() as u32;282283			if !block_pending.is_empty() {284				block_pending.into_iter().for_each(|(staker, amount)| {285					Self::get_locked_balance(&staker).map(|b| {286						let new_state = b.amount.checked_sub(&amount).unwrap_or_default();287						Self::set_lock_unchecked(&staker, new_state);288					});289				});290			}291292			<T as Config>::WeightInfo::on_initialize(counter)293		}294295		fn on_runtime_upgrade() -> Weight {296			let mut consumed_weight = Weight::zero();297			let mut add_weight = |reads, writes, weight| {298				consumed_weight += T::DbWeight::get().reads_writes(reads, writes);299				consumed_weight += weight;300			};301302			if <UpgradedToReserves<T>>::get() {303				add_weight(1, 0, Weight::zero());304				return consumed_weight;305			} else {306				add_weight(1, 1, Weight::zero());307				<UpgradedToReserves<T>>::set(true);308			}309			<PendingUnstake<T>>::drain().for_each(|(_, v)| {310				add_weight(1, 1, Weight::zero());311				v.into_iter().for_each(|(staker, amount)| {312					<<T as Config>::Currency as ReservableCurrency<T::AccountId>>::unreserve(313						&staker, amount,314					);315					add_weight(1, 1, Weight::zero());316				});317			});318319			consumed_weight320		}321322		#[cfg(feature = "try-runtime")]323		fn pre_upgrade() -> Result<Vec<u8>, &'static str> {324			use sp_std::collections::btree_map::BTreeMap;325			if <UpgradedToReserves<T>>::get() {326				return Ok(Default::default());327			}328			// Staker -> (total amount of reserved balance, reserved by promotion);329			let mut pre_state: BTreeMap<T::AccountId, (BalanceOf<T>, BalanceOf<T>)> =330				BTreeMap::new();331332			<PendingUnstake<T>>::iter().for_each(|(_, v)| {333				v.into_iter().for_each(|(staker, amount)| {334					if let Some((_, reserved_balance)) = pre_state.get_mut(&staker) {335						*reserved_balance += amount;336					} else {337						let total_reserve = <<T as Config>::Currency as ReservableCurrency<338							T::AccountId,339						>>::reserved_balance(&staker);340						pre_state.insert(staker, (total_reserve, amount));341					}342				})343			});344345			Ok(pre_state.encode())346		}347348		#[cfg(feature = "try-runtime")]349		fn post_upgrade(pre_state: Vec<u8>) -> Result<(), &'static str> {350			use sp_std::collections::btree_map::BTreeMap;351352			if <UpgradedToReserves<T>>::get() {353				return Ok(());354			}355356			ensure!(357				<PendingUnstake<T>>::iter().collect::<Vec<_>>().len() == 0,358				"pendingUnstake storage isn't empty"359			);360361			let mut is_ok = true;362363			let pre_state: BTreeMap<T::AccountId, (BalanceOf<T>, BalanceOf<T>)> =364				Decode::decode(&mut &pre_state[..]).map_err(|_| "failed to decode pre_state")?;365			for (staker, (total_reserved, reserved_by_promo)) in pre_state.into_iter() {366				let new_state_reserve = <<T as Config>::Currency as ReservableCurrency<367					T::AccountId,368				>>::reserved_balance(&staker);369				if new_state_reserve != total_reserved - reserved_by_promo {370					is_ok = false;371					log::error!(372								"Incorrect reserved balance for {:?}. New balance: {:?}. Before runtime upgrade: total reserve - {:?}, reserved by promo - {:?}",373								staker, new_state_reserve, total_reserved, reserved_by_promo374							);375				}376			}377378			if is_ok {379				Ok(())380			} else {381				Err("Incorrect balance for some of stakers... See logs")382			}383		}384	}385386	#[pallet::call]387	impl<T: Config> Pallet<T>388	where389		T::BlockNumber: From<u32> + Into<u32>,390		<<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum + From<u128>,391	{392		/// Sets an address as the the admin.393		///394		/// # Permissions395		///396		/// * Sudo397		///398		/// # Arguments399		///400		/// * `admin`: account of the new admin.401		#[pallet::call_index(0)]402		#[pallet::weight(<T as Config>::WeightInfo::set_admin_address())]403		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {404			ensure_root(origin)?;405406			<Admin<T>>::set(Some(admin.as_sub().to_owned()));407408			Self::deposit_event(Event::SetAdmin(admin.as_sub().to_owned()));409410			Ok(())411		}412413		/// Stakes the amount of native tokens.414		/// Sets `amount` to the locked state.415		/// The maximum number of stakes for a staker is 10.416		///417		/// # Arguments418		///419		/// * `amount`: in native tokens.420		#[pallet::call_index(1)]421		#[pallet::weight(<T as Config>::WeightInfo::stake())]422		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {423			let staker_id = ensure_signed(staker)?;424425			ensure!(426				StakesPerAccount::<T>::get(&staker_id) < 10,427				Error::<T>::NoPermission428			);429430			ensure!(431				amount >= <BalanceOf<T>>::from(100u128) * T::Nominal::get(),432				ArithmeticError::Underflow433			);434			let config = <PalletConfiguration<T>>::get();435436			let balance =437				<<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);438439			// checks that we can lock `amount` on the `staker` account.440			ensure!(441				amount442					<= match Self::get_locked_balance(&staker_id) {443						Some(lock) => balance444							.checked_sub(&lock.amount)445							.ok_or(ArithmeticError::Underflow)?,446						None => balance,447					},448				ArithmeticError::Underflow449			);450451			Self::add_lock_balance(&staker_id, amount)?;452453			let block_number = T::RelayBlockNumberProvider::current_block_number();454455			// Calculation of the number of recalculation periods,456			// after how much the first interest calculation should be performed for the stake457			let recalculate_after_interval: T::BlockNumber =458				if block_number % config.recalculation_interval == 0u32.into() {459					1u32.into()460				} else {461					2u32.into()462				};463464			// Сalculation of the number of the relay block465			// in which it is necessary to accrue remuneration for the stake.466			let recalc_block = (block_number / config.recalculation_interval467				+ recalculate_after_interval)468				* config.recalculation_interval;469470			<Staked<T>>::insert((&staker_id, block_number), {471				let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));472				balance_and_recalc_block.0 = balance_and_recalc_block473					.0474					.checked_add(&amount)475					.ok_or(ArithmeticError::Overflow)?;476				balance_and_recalc_block.1 = recalc_block;477				balance_and_recalc_block478			});479480			<TotalStaked<T>>::set(481				<TotalStaked<T>>::get()482					.checked_add(&amount)483					.ok_or(ArithmeticError::Overflow)?,484			);485486			StakesPerAccount::<T>::mutate(&staker_id, |stakes| *stakes += 1);487488			Self::deposit_event(Event::Stake(staker_id, amount));489490			Ok(())491		}492493		/// Unstakes all stakes.494		/// After the end of `PendingInterval` this sum becomes completely495		/// free for further use.496		#[pallet::call_index(2)]497		#[pallet::weight(<T as Config>::WeightInfo::unstake_all())]498		pub fn unstake_all(staker: OriginFor<T>) -> DispatchResult {499			let staker_id = ensure_signed(staker)?;500501			Self::unstake_all_internal(staker_id)502		}503504		/// Unstakes the amount of balance for the staker.505		/// After the end of `PendingInterval` this sum becomes completely506		/// free for further use.507		///508		///  # Arguments509		///510		/// * `staker`: staker account.511		/// * `amount`: amount of unstaked funds.512		#[pallet::call_index(8)]513		#[pallet::weight(<T as Config>::WeightInfo::unstake_partial())]514		pub fn unstake_partial(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {515			let staker_id = ensure_signed(staker)?;516517			Self::unstake_partial_internal(staker_id, amount)518		}519520		/// Sets the pallet to be the sponsor for the collection.521		///522		/// # Permissions523		///524		/// * Pallet admin525		///526		/// # Arguments527		///528		/// * `collection_id`: ID of the collection that will be sponsored by `pallet_id`529		#[pallet::call_index(3)]530		#[pallet::weight(<T as Config>::WeightInfo::sponsor_collection())]531		pub fn sponsor_collection(532			admin: OriginFor<T>,533			collection_id: CollectionId,534		) -> DispatchResult {535			let admin_id = ensure_signed(admin)?;536			ensure!(537				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,538				Error::<T>::NoPermission539			);540541			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)542		}543544		/// Removes the pallet as the sponsor for the collection.545		/// Returns [`NoPermission`][`Error::NoPermission`]546		/// if the pallet wasn't the sponsor.547		///548		/// # Permissions549		///550		/// * Pallet admin551		///552		/// # Arguments553		///554		/// * `collection_id`: ID of the collection that is sponsored by `pallet_id`555		#[pallet::call_index(4)]556		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_collection())]557		pub fn stop_sponsoring_collection(558			admin: OriginFor<T>,559			collection_id: CollectionId,560		) -> DispatchResult {561			let admin_id = ensure_signed(admin)?;562563			ensure!(564				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,565				Error::<T>::NoPermission566			);567568			ensure!(569				T::CollectionHandler::sponsor(collection_id)?.ok_or(<Error<T>>::SponsorNotSet)?570					== Self::account_id(),571				<Error<T>>::NoPermission572			);573			T::CollectionHandler::remove_collection_sponsor(collection_id)574		}575576		/// Sets the pallet to be the sponsor for the contract.577		///578		/// # Permissions579		///580		/// * Pallet admin581		///582		/// # Arguments583		///584		/// * `contract_id`: the contract address that will be sponsored by `pallet_id`585		#[pallet::call_index(5)]586		#[pallet::weight(<T as Config>::WeightInfo::sponsor_contract())]587		pub fn sponsor_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {588			let admin_id = ensure_signed(admin)?;589590			ensure!(591				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,592				Error::<T>::NoPermission593			);594595			T::ContractHandler::set_sponsor(596				T::CrossAccountId::from_sub(Self::account_id()),597				contract_id,598			)599		}600601		/// Removes the pallet as the sponsor for the contract.602		/// Returns [`NoPermission`][`Error::NoPermission`]603		/// if the pallet wasn't the sponsor.604		///605		/// # Permissions606		///607		/// * Pallet admin608		///609		/// # Arguments610		///611		/// * `contract_id`: the contract address that is sponsored by `pallet_id`612		#[pallet::call_index(6)]613		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_contract())]614		pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {615			let admin_id = ensure_signed(admin)?;616617			ensure!(618				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,619				Error::<T>::NoPermission620			);621622			ensure!(623				T::ContractHandler::sponsor(contract_id)?624					.ok_or(<Error<T>>::SponsorNotSet)?625					.as_sub() == &Self::account_id(),626				<Error<T>>::NoPermission627			);628			T::ContractHandler::remove_contract_sponsor(contract_id)629		}630631		/// Recalculates interest for the specified number of stakers.632		/// If all stakers are not recalculated, the next call of the extrinsic633		/// will continue the recalculation, from those stakers for whom this634		/// was not perform in last call.635		///636		/// # Permissions637		///638		/// * Pallet admin639		///640		/// # Arguments641		///642		/// * `stakers_number`: the number of stakers for which recalculation will be performed643		#[pallet::call_index(7)]644		#[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]645		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {646			let admin_id = ensure_signed(admin)?;647648			ensure!(649				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,650				Error::<T>::NoPermission651			);652			let config = <PalletConfiguration<T>>::get();653654			let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);655656			ensure!(657				stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,658				Error::<T>::NoPermission659			);660661			// calculate the number of the current recalculation block,662			// this is necessary in order to understand which stakers we should calculate interest663			let current_recalc_block = Self::get_current_recalc_block(664				T::RelayBlockNumberProvider::current_block_number(),665				&config,666			);667668			// calculate the number of the next recalculation block,669			// this value is set for the stakers to whom the recalculation will be performed670			let next_recalc_block = current_recalc_block + config.recalculation_interval;671672			let mut storage_iterator = Self::get_next_calculated_key()673				.map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));674675			PreviousCalculatedRecord::<T>::set(None);676677			{678				// Address handled in the last payout loop iteration (below)679				let last_id = RefCell::new(None);680				// Block number (as a part of the key) for which calculation was performed in the last payout loop iteration681				let mut last_staked_calculated_block = Default::default();682				// Reward balance for the address in the iteration683				let income_acc = RefCell::new(BalanceOf::<T>::default());684				// Staked balance for the address in the iteration (before stake is recalculated)685				let amount_acc = RefCell::new(BalanceOf::<T>::default());686687				// This closure is used to finalize handling single staker address in each of the two conditions: (1) when we break out of the payout688				// loop because we reached the number of stakes for rewarding, (2) When all stakes by the single address are handled and the payout689				// loop switches to handling the next staker address:690				//   1. Transfer full reward amount to the payee691				//   2. Lock the reward in staking lock692				//   3. Update TotalStaked amount693				//   4. Issue StakingRecalculation event694				let flush_stake = || -> DispatchResult {695					if let Some(last_id) = &*last_id.borrow() {696						if !income_acc.borrow().is_zero() {697							<<T as Config>::Currency as Currency<T::AccountId>>::transfer(698								&T::TreasuryAccountId::get(),699								last_id,700								*income_acc.borrow(),701								ExistenceRequirement::KeepAlive,702							)?;703704							Self::add_lock_balance(last_id, *income_acc.borrow())?;705							<TotalStaked<T>>::try_mutate(|staked| -> DispatchResult {706								*staked = staked707									.checked_add(&*income_acc.borrow())708									.ok_or(ArithmeticError::Overflow)?;709								Ok(())710							})?;711712							Self::deposit_event(Event::StakingRecalculation(713								last_id.clone(),714								*amount_acc.borrow(),715								*income_acc.borrow(),716							));717						}718719						*income_acc.borrow_mut() = BalanceOf::<T>::default();720						*amount_acc.borrow_mut() = BalanceOf::<T>::default();721					}722					Ok(())723				};724725				// Reward payment loop. Should loop for no more than config.max_stakers_per_calculation726				// iterations in one extrinsic call727				//728				// stakers_number - keeps the remaining number of iterations (staker addresses to handle)729				// next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out730				// income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)731				while let Some((732					(current_id, staked_block),733					(amount, next_recalc_block_for_stake),734				)) = storage_iterator.next()735				{736					// last_id is not equal current_id when we switch to handling a new staker address737					// or just start handling the very first address. In the latter case last_id will be None and738					// flush_stake will do nothing739					if last_id.borrow().as_ref() != Some(&current_id) {740						if stakers_number > 0 {741							flush_stake()?;742							*last_id.borrow_mut() = Some(current_id.clone());743							stakers_number -= 1;744						}745						// Break out if we reached the address limit746						else {747							if let Some(staker) = &*last_id.borrow() {748								// Save the last calculated record to pick up in the next extrinsic call749								PreviousCalculatedRecord::<T>::set(Some((750									staker.clone(),751									last_staked_calculated_block,752								)));753							}754							break;755						};756					};757758					// Increase accumulated reward for current address and update current staking record, i.e. (address, staked_block) -> amount759					if current_recalc_block >= next_recalc_block_for_stake {760						*amount_acc.borrow_mut() += amount;761						Self::recalculate_and_insert_stake(762							&current_id,763							staked_block,764							next_recalc_block,765							amount,766							((current_recalc_block - next_recalc_block_for_stake)767								/ config.recalculation_interval)768								.into() + 1,769							&mut *income_acc.borrow_mut(),770						);771					}772					last_staked_calculated_block = staked_block;773				}774				flush_stake()?;775			}776777			Ok(())778		}779	}780}781782impl<T: Config> Pallet<T> {783	/// The account address of the app promotion pot.784	///785	/// This actually does computation. If you need to keep using it, then make sure you cache the786	/// value and only call this once.787	pub fn account_id() -> T::AccountId {788		T::PalletId::get().into_account_truncating()789	}790791	/// Unstakes the balance for the staker.792	///793	/// - `staker`: staker account.794	/// - `amount`: amount of unstaked funds.795	fn unstake_partial_internal(796		staker_id: T::AccountId,797		unstaked_balance: BalanceOf<T>,798	) -> DispatchResult {799		if unstaked_balance == Default::default() {800			return Ok(());801		}802803		let config = <PalletConfiguration<T>>::get();804805		// calculate block number where the sum would be free806		let unpending_block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;807808		let mut pendings = <PendingUnstake<T>>::get(unpending_block);809810		// checks that we can do unstake in the block811		ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);812813		let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();814815		let total_staked = stakes816			.iter()817			.fold(<BalanceOf<T>>::default(), |acc, (_, (balance, _))| {818				acc + *balance819			});820821		ensure!(822			unstaked_balance <= total_staked,823			<Error<T>>::InsufficientStakedBalance824		);825826		<TotalStaked<T>>::set(827			<TotalStaked<T>>::get()828				.checked_sub(&unstaked_balance)829				.ok_or(ArithmeticError::Underflow)?,830		);831832		stakes.sort_by_key(|(block, _)| *block);833834		let mut acc_amount = unstaked_balance;835		let mut will_deleted_stakes_count = 0u8;836837		let changed_stakes = stakes838			.into_iter()839			.map_while(|(block, (balance_per_block, _))| {840				if acc_amount == <BalanceOf<T>>::default() {841					return None;842				}843				if acc_amount < balance_per_block {844					let res = (block, balance_per_block - acc_amount);845					acc_amount = <BalanceOf<T>>::default();846					return Some(res);847				} else {848					acc_amount -= balance_per_block;849					will_deleted_stakes_count += 1;850					return Some((block, <BalanceOf<T>>::default()));851				}852			})853			.collect::<Vec<_>>();854855		pendings856			.try_push((staker_id.clone(), unstaked_balance))857			.map_err(|_| Error::<T>::PendingForBlockOverflow)?;858859		StakesPerAccount::<T>::try_mutate(&staker_id, |stakes| -> DispatchResult {860			*stakes = stakes861				.checked_sub(will_deleted_stakes_count)862				.ok_or(ArithmeticError::Underflow)?;863			Ok(())864		})?;865866		changed_stakes867			.into_iter()868			.for_each(|(staked_block, current_stake_state)| {869				if current_stake_state == Default::default() {870					<Staked<T>>::remove((&staker_id, staked_block));871				} else {872					<Staked<T>>::mutate((&staker_id, staked_block), |(old_stake_state, _)| {873						*old_stake_state = current_stake_state874					});875				}876			});877878		<PendingUnstake<T>>::insert(unpending_block, pendings);879880		Self::deposit_event(Event::Unstake(staker_id, total_staked));881882		Ok(())883	}884885	/// Adds the balance to locked by the pallet.886	///887	/// - `staker`: staker account.888	/// - `amount`: amount of added locked funds.889	fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {890		Self::get_locked_balance(staker)891			.map_or(<BalanceOf<T>>::default(), |l| l.amount)892			.checked_add(&amount)893			.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))894			.ok_or(ArithmeticError::Overflow.into())895	}896897	/// Sets the new state of a balance locked by the pallet.898	///899	/// - `staker`: staker account.900	/// - `amount`: amount of locked funds.901	fn set_lock_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {902		if amount.is_zero() {903			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(904				LOCK_IDENTIFIER,905				&staker,906			);907		} else {908			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::set_lock(909				LOCK_IDENTIFIER,910				staker,911				amount,912				WithdrawReasons::all(),913			)914		}915	}916917	/// Returns the balance locked by the pallet for the staker.918	///919	/// - `staker`: staker account.920	pub fn get_locked_balance(921		staker: impl EncodeLike<T::AccountId>,922	) -> Option<BalanceLock<BalanceOf<T>>> {923		<<T as Config>::Currency as ExtendedLockableCurrency<T::AccountId>>::locks(staker)924			.into_iter()925			.find(|l| l.id == LOCK_IDENTIFIER)926	}927928	/// Returns the total staked balance for the staker.929	///930	/// - `staker`: staker account.931	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {932		let staked = Staked::<T>::iter_prefix((staker,))933			.into_iter()934			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {935				acc + amount936			});937		if staked != <BalanceOf<T>>::default() {938			Some(staked)939		} else {940			None941		}942	}943944	/// Returns all relay block numbers when stake was made,945	/// the amount of the stake.946	///947	/// - `staker`: staker account.948	pub fn total_staked_by_id_per_block(949		staker: impl EncodeLike<T::AccountId>,950	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {951		let mut staked = Staked::<T>::iter_prefix((staker,))952			.into_iter()953			.map(|(block, (amount, _))| (block, amount))954			.collect::<Vec<_>>();955		staked.sort_by_key(|(block, _)| *block);956		if !staked.is_empty() {957			Some(staked)958		} else {959			None960		}961	}962963	/// Returns the total staked balance for the staker.964	/// If `staker` is `None`, returns the total amount staked.965	/// - `staker`: staker account.966	pub fn cross_id_total_staked(staker: Option<T::CrossAccountId>) -> Option<BalanceOf<T>> {967		staker.map_or(Some(<TotalStaked<T>>::get()), |s| {968			Self::total_staked_by_id(s.as_sub())969		})970	}971972	// pub fn cross_id_locked_balance(staker: T::CrossAccountId) -> BalanceOf<T> {973	// 	Self::get_locked_balance(staker.as_sub())974	// 		.map(|l| l.amount)975	// 		.unwrap_or_default()976	// }977978	/// Returns all relay block numbers when stake was made,979	/// the amount of the stake.980	///981	/// - `staker`: staker account.982	pub fn cross_id_total_staked_per_block(983		staker: T::CrossAccountId,984	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {985		Self::total_staked_by_id_per_block(staker.as_sub()).unwrap_or_default()986	}987988	fn recalculate_and_insert_stake(989		staker: &T::AccountId,990		staked_block: T::BlockNumber,991		next_recalc_block: T::BlockNumber,992		base: BalanceOf<T>,993		iters: u32,994		income_acc: &mut BalanceOf<T>,995	) {996		let income = Self::calculate_income(base, iters);997998		base.checked_add(&income).map(|res| {999			<Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));1000			*income_acc += income;1001		});1002	}10031004	fn calculate_income<I>(base: I, iters: u32) -> I1005	where1006		I: EncodeLike<BalanceOf<T>> + Balance,1007	{1008		let config = <PalletConfiguration<T>>::get();1009		let mut income = base;10101011		(0..iters).for_each(|_| income += config.interval_income * income);10121013		income - base1014	}10151016	/// Get relay block number rounded down to multiples of config.recalculation_interval.1017	/// We need it to reward stakers in integer parts of recalculation_interval1018	fn get_current_recalc_block(1019		current_relay_block: T::BlockNumber,1020		config: &PalletConfiguration<T>,1021	) -> T::BlockNumber {1022		(current_relay_block / config.recalculation_interval) * config.recalculation_interval1023	}10241025	fn get_next_calculated_key() -> Option<Vec<u8>> {1026		Self::get_next_calculated_record().map(|key| Staked::<T>::hashed_key_for(key))1027	}1028}10291030impl<T: Config> Pallet<T>1031where1032	<<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum,1033{1034	/// Returns the amount reserved by the pending.1035	/// If `staker` is `None`, returns the total pending.1036	///1037	/// -`staker`: staker account.1038	///1039	/// Since user funds are not transferred anywhere by staking, overflow protection is provided1040	/// at the level of the associated type `Balance` of `Currency` trait. In order to overflow,1041	/// the staker must have more funds on his account than the maximum set for `Balance` type.1042	pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {1043		staker.map_or(1044			PendingUnstake::<T>::iter_values()1045				.flat_map(|pendings| pendings.into_iter().map(|(_, amount)| amount))1046				.sum(),1047			|s| {1048				PendingUnstake::<T>::iter_values()1049					.flatten()1050					.filter_map(|(id, amount)| {1051						if id == *s.as_sub() {1052							Some(amount)1053						} else {1054							None1055						}1056					})1057					.sum()1058			},1059		)1060	}10611062	/// Returns all parachain block numbers when unreserve is expected,1063	/// the amount of the unreserved funds.1064	///1065	/// - `staker`: staker account.1066	pub fn cross_id_pending_unstake_per_block(1067		staker: T::CrossAccountId,1068	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1069		let mut unsorted_res = vec![];1070		PendingUnstake::<T>::iter().for_each(|(block, pendings)| {1071			pendings.into_iter().for_each(|(id, amount)| {1072				if id == *staker.as_sub() {1073					unsorted_res.push((block, amount));1074				};1075			})1076		});10771078		unsorted_res.sort_by_key(|(block, _)| *block);1079		unsorted_res1080	}10811082	fn unstake_all_internal(staker_id: T::AccountId) -> DispatchResult {1083		let config = <PalletConfiguration<T>>::get();10841085		// calculate block number where the sum would be free1086		let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;10871088		let mut pendings = <PendingUnstake<T>>::get(block);10891090		// checks that we can do unstake in the block1091		ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);10921093		let mut total_stakes = 0u64;10941095		let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))1096			.map(|(_, (amount, _))| {1097				total_stakes += 1;1098				amount1099			})1100			.sum();11011102		if total_staked.is_zero() {1103			return Ok(());1104		}11051106		pendings1107			.try_push((staker_id.clone(), total_staked))1108			.map_err(|_| Error::<T>::PendingForBlockOverflow)?;11091110		<PendingUnstake<T>>::insert(block, pendings);11111112		TotalStaked::<T>::set(1113			TotalStaked::<T>::get()1114				.checked_sub(&total_staked)1115				.ok_or(ArithmeticError::Underflow)?,1116		);11171118		StakesPerAccount::<T>::remove(&staker_id);11191120		Self::deposit_event(Event::Unstake(staker_id, total_staked));11211122		Ok(())1123	}1124}