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

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,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,100		pallet_prelude::{*, ValueQuery, StorageValue},101		storage::Key,102		PalletId,103		traits::ReservableCurrency,104		weights::Weight,105	};106	use frame_system::pallet_prelude::*;107108	#[pallet::config]109	pub trait Config:110		frame_system::Config + pallet_evm::Config + pallet_configuration::Config111	{112		/// Type to interact with the native token113		type Currency: ExtendedLockableCurrency<Self::AccountId>114			+ ReservableCurrency<Self::AccountId>;115116		/// Type for interacting with collections117		type CollectionHandler: CollectionHandler<118			AccountId = Self::AccountId,119			CollectionId = CollectionId,120		>;121122		/// Type for interacting with conrtacts123		type ContractHandler: ContractHandler<AccountId = Self::CrossAccountId, ContractId = H160>;124125		/// `AccountId` for treasury126		type TreasuryAccountId: Get<Self::AccountId>;127128		/// The app's pallet id, used for deriving its sovereign account address.129		#[pallet::constant]130		type PalletId: Get<PalletId>;131132		/// In relay blocks.133		#[pallet::constant]134		type RecalculationInterval: Get<Self::BlockNumber>;135136		/// In parachain blocks.137		#[pallet::constant]138		type PendingInterval: Get<Self::BlockNumber>;139140		/// Rate of return for interval in blocks defined in `RecalculationInterval`.141		#[pallet::constant]142		type IntervalIncome: Get<Perbill>;143144		/// Decimals for the `Currency`.145		#[pallet::constant]146		type Nominal: Get<BalanceOf<Self>>;147148		/// Weight information for extrinsics in this pallet.149		type WeightInfo: WeightInfo;150151		// The relay block number provider152		type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;153154		/// Events compatible with [`frame_system::Config::Event`].155		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;156	}157158	#[pallet::pallet]159	#[pallet::generate_store(pub(super) trait Store)]160	pub struct Pallet<T>(_);161162	#[pallet::event]163	#[pallet::generate_deposit(fn deposit_event)]164	pub enum Event<T: Config> {165		/// Staking recalculation was performed166		///167		/// # Arguments168		/// * AccountId: account of the staker.169		/// * Balance : recalculation base170		/// * Balance : total income171		StakingRecalculation(172			/// An recalculated staker173			T::AccountId,174			/// Base on which interest is calculated175			BalanceOf<T>,176			/// Amount of accrued interest177			BalanceOf<T>,178		),179180		/// Staking was performed181		///182		/// # Arguments183		/// * AccountId: account of the staker184		/// * Balance : staking amount185		Stake(T::AccountId, BalanceOf<T>),186187		/// Unstaking was performed188		///189		/// # Arguments190		/// * AccountId: account of the staker191		/// * Balance : unstaking amount192		Unstake(T::AccountId, BalanceOf<T>),193194		/// The admin was set195		///196		/// # Arguments197		/// * AccountId: account address of the admin198		SetAdmin(T::AccountId),199	}200201	#[pallet::error]202	pub enum Error<T> {203		/// Error due to action requiring admin to be set.204		AdminNotSet,205		/// No permission to perform an action.206		NoPermission,207		/// Insufficient funds to perform an action.208		NotSufficientFunds,209		/// Occurs when a pending unstake cannot be added in this block. PENDING_LIMIT_PER_BLOCK` limits exceeded.210		PendingForBlockOverflow,211		/// The error is due to the fact that the collection/contract must already be sponsored in order to perform the action.212		SponsorNotSet,213		/// Errors caused by incorrect actions with a locked balance.214		IncorrectLockedBalanceOperation,215	}216217	/// Stores the total staked amount.218	#[pallet::storage]219	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;220221	/// Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.222	#[pallet::storage]223	pub type Admin<T: Config> = StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;224225	/// Stores the amount of tokens staked by account in the blocknumber.226	///227	/// * **Key1** - Staker account.228	/// * **Key2** - Relay block number when the stake was made.229	/// * **(Balance, BlockNumber)** - Balance of the stake.230	/// The number of the relay block in which we must perform the interest recalculation231	#[pallet::storage]232	pub type Staked<T: Config> = StorageNMap<233		Key = (234			Key<Blake2_128Concat, T::AccountId>,235			Key<Twox64Concat, T::BlockNumber>,236		),237		Value = (BalanceOf<T>, T::BlockNumber),238		QueryKind = ValueQuery,239	>;240241	/// Stores amount of stakes for an `Account`.242	///243	/// * **Key** - Staker account.244	/// * **Value** - Amount of stakes.245	#[pallet::storage]246	pub type StakesPerAccount<T: Config> =247		StorageMap<_, Blake2_128Concat, T::AccountId, u8, ValueQuery>;248249	/// Stores amount of stakes for an `Account`.250	///251	/// * **Key** - Staker account.252	/// * **Value** - Amount of stakes.253	#[pallet::storage]254	pub type PendingUnstake<T: Config> = StorageMap<255		_,256		Twox64Concat,257		T::BlockNumber,258		BoundedVec<(T::AccountId, BalanceOf<T>), ConstU32<PENDING_LIMIT_PER_BLOCK>>,259		ValueQuery,260	>;261262	/// Stores a key for record for which the revenue recalculation was performed.263	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.264	#[pallet::storage]265	#[pallet::getter(fn get_next_calculated_record)]266	pub type PreviousCalculatedRecord<T: Config> =267		StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;268269	#[pallet::storage]270	pub(crate) type IsMigrated<T: Config> = StorageValue<Value = bool, QueryKind = ValueQuery>;271272	#[pallet::hooks]273	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {274		/// Block overflow is impossible due to the fact that the unstake algorithm in on_initialize275		/// implies the execution of a strictly limited number of relatively lightweight operations.276		/// A separate benchmark has been implemented to scale the weight depending on the number of pendings.277		fn on_initialize(current_block_number: T::BlockNumber) -> Weight278		where279			<T as frame_system::Config>::BlockNumber: From<u32>,280		{281			let block_pending = PendingUnstake::<T>::take(current_block_number);282			let counter = block_pending.len() as u32;283284			if !block_pending.is_empty() {285				block_pending.into_iter().for_each(|(staker, amount)| {286					Self::get_locked_balance(&staker).map(|b| {287						let new_state = b.amount.checked_sub(&amount).unwrap_or_default();288						Self::set_lock_unchecked(&staker, new_state);289					});290				});291			}292293			<T as Config>::WeightInfo::on_initialize(counter)294		}295296		fn on_runtime_upgrade() -> Weight {297			let mut consumed_weight = Weight::zero();298			let mut add_weight = |reads, writes, weight| {299				consumed_weight += T::DbWeight::get().reads_writes(reads, writes);300				consumed_weight += weight;301			};302303			if <IsMigrated<T>>::get() {304				add_weight(1, 0, Weight::zero());305				return consumed_weight;306			} else {307				add_weight(1, 1, Weight::zero());308				<IsMigrated<T>>::set(true);309			}310			<PendingUnstake<T>>::drain().for_each(|(_, v)| {311				add_weight(1, 1, Weight::zero());312				v.into_iter().for_each(|(staker, amount)| {313					<<T as Config>::Currency as ReservableCurrency<T::AccountId>>::unreserve(314						&staker, amount,315					);316					add_weight(1, 1, Weight::zero());317				});318			});319320			consumed_weight321		}322323		#[cfg(feature = "try-runtime")]324		fn pre_upgrade() -> Result<Vec<u8>, &'static str> {325			use sp_std::collections::btree_map::BTreeMap;326			if <IsMigrated<T>>::get() {327				return Ok(Default::default());328			}329			// Staker -> (total amount of reserved balance, reserved by promotion);330			let mut pre_state: BTreeMap<T::AccountId, (BalanceOf<T>, BalanceOf<T>)> =331				BTreeMap::new();332333			<PendingUnstake<T>>::iter().for_each(|(_, v)| {334				v.into_iter().for_each(|(staker, amount)| {335					if let Some((_, reserved_balance)) = pre_state.get_mut(&staker) {336						*reserved_balance += amount;337					} else {338						let total_reserve = <<T as Config>::Currency as ReservableCurrency<339							T::AccountId,340						>>::reserved_balance(&staker);341						pre_state.insert(staker, (total_reserve, amount));342					}343				})344			});345346			Ok(pre_state.encode())347		}348349		#[cfg(feature = "try-runtime")]350		fn post_upgrade(pre_state: Vec<u8>) -> Result<(), &'static str> {351			use sp_std::collections::btree_map::BTreeMap;352353			if <IsMigrated<T>>::get() {354				return Ok(());355			}356			357			ensure!(358				<PendingUnstake<T>>::iter().collect::<Vec<_>>().len() == 0,359				"pendingUnstake storage isn't empty"360			);361			362			let mut is_ok = true;363364			let pre_state: BTreeMap<T::AccountId, (BalanceOf<T>, BalanceOf<T>)> =365				Decode::decode(&mut &pre_state[..]).map_err(|_| "failed to decode pre_state")?;366			for (staker, (total_reserved, reserved_by_promo)) in pre_state.into_iter() {367				let new_state_reserve = <<T as Config>::Currency as ReservableCurrency<368					T::AccountId,369				>>::reserved_balance(&staker);370				if new_state_reserve != total_reserved - reserved_by_promo {371					is_ok = false;372					log::error!(373								"Incorrect reserved balance for {:?}. New balance: {:?}. Before runtime upgrade: total reserve - {:?}, reserved by promo - {:?}",374								staker, new_state_reserve, total_reserved, reserved_by_promo375							);376				}377			}378379			if is_ok {380				Ok(())381			} else {382				Err("Incorrect balance for some of stakers... See logs")383			}384		}385	}386387	#[pallet::call]388	impl<T: Config> Pallet<T>389	where390		T::BlockNumber: From<u32> + Into<u32>,391		<<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum + From<u128>,392	{393		/// Sets an address as the the admin.394		///395		/// # Permissions396		///397		/// * Sudo398		///399		/// # Arguments400		///401		/// * `admin`: account of the new admin.402		#[pallet::call_index(0)]403		#[pallet::weight(<T as Config>::WeightInfo::set_admin_address())]404		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {405			ensure_root(origin)?;406407			<Admin<T>>::set(Some(admin.as_sub().to_owned()));408409			Self::deposit_event(Event::SetAdmin(admin.as_sub().to_owned()));410411			Ok(())412		}413414		/// Stakes the amount of native tokens.415		/// Sets `amount` to the locked state.416		/// The maximum number of stakes for a staker is 10.417		///418		/// # Arguments419		///420		/// * `amount`: in native tokens.421		#[pallet::call_index(1)]422		#[pallet::weight(<T as Config>::WeightInfo::stake())]423		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {424			let staker_id = ensure_signed(staker)?;425426			ensure!(427				StakesPerAccount::<T>::get(&staker_id) < 10,428				Error::<T>::NoPermission429			);430431			ensure!(432				amount >= <BalanceOf<T>>::from(100u128) * T::Nominal::get(),433				ArithmeticError::Underflow434			);435			let config = <PalletConfiguration<T>>::get();436437			let balance =438				<<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);439440			// checks that we can lock `amount` on the `staker` account.441			ensure!(442				amount443					<= match Self::get_locked_balance(&staker_id) {444						Some(lock) => balance445							.checked_sub(&lock.amount)446							.ok_or(ArithmeticError::Underflow)?,447						None => balance,448					},449				ArithmeticError::Underflow450			);451452			Self::add_lock_balance(&staker_id, amount)?;453454			let block_number = T::RelayBlockNumberProvider::current_block_number();455456			// Calculation of the number of recalculation periods,457			// after how much the first interest calculation should be performed for the stake458			let recalculate_after_interval: T::BlockNumber =459				if block_number % config.recalculation_interval == 0u32.into() {460					1u32.into()461				} else {462					2u32.into()463				};464465			// Сalculation of the number of the relay block466			// in which it is necessary to accrue remuneration for the stake.467			let recalc_block = (block_number / config.recalculation_interval468				+ recalculate_after_interval)469				* config.recalculation_interval;470471			<Staked<T>>::insert((&staker_id, block_number), {472				let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));473				balance_and_recalc_block.0 = balance_and_recalc_block474					.0475					.checked_add(&amount)476					.ok_or(ArithmeticError::Overflow)?;477				balance_and_recalc_block.1 = recalc_block;478				balance_and_recalc_block479			});480481			<TotalStaked<T>>::set(482				<TotalStaked<T>>::get()483					.checked_add(&amount)484					.ok_or(ArithmeticError::Overflow)?,485			);486487			StakesPerAccount::<T>::mutate(&staker_id, |stakes| *stakes += 1);488489			Self::deposit_event(Event::Stake(staker_id, amount));490491			Ok(())492		}493494		/// Unstakes all stakes.495		/// Moves the sum of all stakes to the `reserved` state.496		/// After the end of `PendingInterval` this sum becomes completely497		/// free for further use.498		#[pallet::call_index(2)]499		#[pallet::weight(<T as Config>::WeightInfo::unstake())]500		pub fn unstake(staker: OriginFor<T>) -> DispatchResultWithPostInfo {501			let staker_id = ensure_signed(staker)?;502			let config = <PalletConfiguration<T>>::get();503504			// calculate block number where the sum would be free505			let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;506507			let mut pendings = <PendingUnstake<T>>::get(block);508509			// checks that we can do unreserve stakes in the block510			ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);511512			let mut total_stakes = 0u64;513514			let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))515				.map(|(_, (amount, _))| {516					total_stakes += 1;517					amount518				})519				.sum();520521			if total_staked.is_zero() {522				return Ok(None::<Weight>.into()); // TO-DO523			}524525			pendings526				.try_push((staker_id.clone(), total_staked))527				.map_err(|_| Error::<T>::PendingForBlockOverflow)?;528529			<PendingUnstake<T>>::insert(block, pendings);530531532			TotalStaked::<T>::set(533				TotalStaked::<T>::get()534					.checked_sub(&total_staked)535					.ok_or(ArithmeticError::Underflow)?,536			);537538			StakesPerAccount::<T>::remove(&staker_id);539540			Self::deposit_event(Event::Unstake(staker_id, total_staked));541542			Ok(None::<Weight>.into())543		}544545		/// Sets the pallet to be the sponsor for the collection.546		///547		/// # Permissions548		///549		/// * Pallet admin550		///551		/// # Arguments552		///553		/// * `collection_id`: ID of the collection that will be sponsored by `pallet_id`554		#[pallet::call_index(3)]555		#[pallet::weight(<T as Config>::WeightInfo::sponsor_collection())]556		pub fn sponsor_collection(557			admin: OriginFor<T>,558			collection_id: CollectionId,559		) -> DispatchResult {560			let admin_id = ensure_signed(admin)?;561			ensure!(562				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,563				Error::<T>::NoPermission564			);565566			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)567		}568569		/// Removes the pallet as the sponsor for the collection.570		/// Returns [`NoPermission`][`Error::NoPermission`]571		/// if the pallet wasn't the sponsor.572		///573		/// # Permissions574		///575		/// * Pallet admin576		///577		/// # Arguments578		///579		/// * `collection_id`: ID of the collection that is sponsored by `pallet_id`580		#[pallet::call_index(4)]581		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_collection())]582		pub fn stop_sponsoring_collection(583			admin: OriginFor<T>,584			collection_id: CollectionId,585		) -> DispatchResult {586			let admin_id = ensure_signed(admin)?;587588			ensure!(589				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,590				Error::<T>::NoPermission591			);592593			ensure!(594				T::CollectionHandler::sponsor(collection_id)?.ok_or(<Error<T>>::SponsorNotSet)?595					== Self::account_id(),596				<Error<T>>::NoPermission597			);598			T::CollectionHandler::remove_collection_sponsor(collection_id)599		}600601		/// Sets the pallet to be the sponsor for the contract.602		///603		/// # Permissions604		///605		/// * Pallet admin606		///607		/// # Arguments608		///609		/// * `contract_id`: the contract address that will be sponsored by `pallet_id`610		#[pallet::call_index(5)]611		#[pallet::weight(<T as Config>::WeightInfo::sponsor_contract())]612		pub fn sponsor_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {613			let admin_id = ensure_signed(admin)?;614615			ensure!(616				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,617				Error::<T>::NoPermission618			);619620			T::ContractHandler::set_sponsor(621				T::CrossAccountId::from_sub(Self::account_id()),622				contract_id,623			)624		}625626		/// Removes the pallet as the sponsor for the contract.627		/// Returns [`NoPermission`][`Error::NoPermission`]628		/// if the pallet wasn't the sponsor.629		///630		/// # Permissions631		///632		/// * Pallet admin633		///634		/// # Arguments635		///636		/// * `contract_id`: the contract address that is sponsored by `pallet_id`637		#[pallet::call_index(6)]638		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_contract())]639		pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {640			let admin_id = ensure_signed(admin)?;641642			ensure!(643				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,644				Error::<T>::NoPermission645			);646647			ensure!(648				T::ContractHandler::sponsor(contract_id)?649					.ok_or(<Error<T>>::SponsorNotSet)?650					.as_sub() == &Self::account_id(),651				<Error<T>>::NoPermission652			);653			T::ContractHandler::remove_contract_sponsor(contract_id)654		}655656		/// Recalculates interest for the specified number of stakers.657		/// If all stakers are not recalculated, the next call of the extrinsic658		/// will continue the recalculation, from those stakers for whom this659		/// was not perform in last call.660		///661		/// # Permissions662		///663		/// * Pallet admin664		///665		/// # Arguments666		///667		/// * `stakers_number`: the number of stakers for which recalculation will be performed668		#[pallet::call_index(7)]669		#[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]670		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {671			let admin_id = ensure_signed(admin)?;672673			ensure!(674				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,675				Error::<T>::NoPermission676			);677			let config = <PalletConfiguration<T>>::get();678679			let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);680681			ensure!(682				stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,683				Error::<T>::NoPermission684			);685686			// calculate the number of the current recalculation block,687			// this is necessary in order to understand which stakers we should calculate interest688			let current_recalc_block = Self::get_current_recalc_block(689				T::RelayBlockNumberProvider::current_block_number(),690				&config,691			);692693			// calculate the number of the next recalculation block,694			// this value is set for the stakers to whom the recalculation will be performed695			let next_recalc_block = current_recalc_block + config.recalculation_interval;696697			let mut storage_iterator = Self::get_next_calculated_key()698				.map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));699700			PreviousCalculatedRecord::<T>::set(None);701702			{703				// Address handled in the last payout loop iteration (below)704				let last_id = RefCell::new(None);705				// Block number (as a part of the key) for which calculation was performed in the last payout loop iteration706				let mut last_staked_calculated_block = Default::default();707				// Reward balance for the address in the iteration708				let income_acc = RefCell::new(BalanceOf::<T>::default());709				// Staked balance for the address in the iteration (before stake is recalculated)710				let amount_acc = RefCell::new(BalanceOf::<T>::default());711712				// This closure is used to finalize handling single staker address in each of the two conditions: (1) when we break out of the payout713				// loop because we reached the number of stakes for rewarding, (2) When all stakes by the single address are handled and the payout714				// loop switches to handling the next staker address:715				//   1. Transfer full reward amount to the payee716				//   2. Lock the reward in staking lock717				//   3. Update TotalStaked amount718				//   4. Issue StakingRecalculation event719				let flush_stake = || -> DispatchResult {720					if let Some(last_id) = &*last_id.borrow() {721						if !income_acc.borrow().is_zero() {722							<<T as Config>::Currency as Currency<T::AccountId>>::transfer(723								&T::TreasuryAccountId::get(),724								last_id,725								*income_acc.borrow(),726								ExistenceRequirement::KeepAlive,727							)?;728729							Self::add_lock_balance(last_id, *income_acc.borrow())?;730							<TotalStaked<T>>::try_mutate(|staked| -> DispatchResult {731								*staked = staked732									.checked_add(&*income_acc.borrow())733									.ok_or(ArithmeticError::Overflow)?;734								Ok(())735							})?;736737							Self::deposit_event(Event::StakingRecalculation(738								last_id.clone(),739								*amount_acc.borrow(),740								*income_acc.borrow(),741							));742						}743744						*income_acc.borrow_mut() = BalanceOf::<T>::default();745						*amount_acc.borrow_mut() = BalanceOf::<T>::default();746					}747					Ok(())748				};749750				// Reward payment loop. Should loop for no more than config.max_stakers_per_calculation751				// iterations in one extrinsic call752				//753				// stakers_number - keeps the remaining number of iterations (staker addresses to handle)754				// next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out755				// income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)756				while let Some((757					(current_id, staked_block),758					(amount, next_recalc_block_for_stake),759				)) = storage_iterator.next()760				{761					// last_id is not equal current_id when we switch to handling a new staker address762					// or just start handling the very first address. In the latter case last_id will be None and763					// flush_stake will do nothing764					if last_id.borrow().as_ref() != Some(&current_id) {765						if stakers_number > 0 {766							flush_stake()?;767							*last_id.borrow_mut() = Some(current_id.clone());768							stakers_number -= 1;769						}770						// Break out if we reached the address limit771						else {772							if let Some(staker) = &*last_id.borrow() {773								// Save the last calculated record to pick up in the next extrinsic call774								PreviousCalculatedRecord::<T>::set(Some((775									staker.clone(),776									last_staked_calculated_block,777								)));778							}779							break;780						};781					};782783					// Increase accumulated reward for current address and update current staking record, i.e. (address, staked_block) -> amount784					if current_recalc_block >= next_recalc_block_for_stake {785						*amount_acc.borrow_mut() += amount;786						Self::recalculate_and_insert_stake(787							&current_id,788							staked_block,789							next_recalc_block,790							amount,791							((current_recalc_block - next_recalc_block_for_stake)792								/ config.recalculation_interval)793								.into() + 1,794							&mut *income_acc.borrow_mut(),795						);796					}797					last_staked_calculated_block = staked_block;798				}799				flush_stake()?;800			}801802			Ok(())803		}804	}805}806807impl<T: Config> Pallet<T> {808	/// The account address of the app promotion pot.809	///810	/// This actually does computation. If you need to keep using it, then make sure you cache the811	/// value and only call this once.812	pub fn account_id() -> T::AccountId {813		T::PalletId::get().into_account_truncating()814	}815816	// /// Unlocks the balance that was locked by the pallet.817	// ///818	// /// - `staker`: staker account.819	// /// - `amount`: amount of unlocked funds.820	// fn unlock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {821	// 	let locked_balance = Self::get_locked_balance(staker)822	// 		.map(|l| l.amount)823	// 		.ok_or(<Error<T>>::IncorrectLockedBalanceOperation)?;824825	// 	// It is understood that we cannot unlock more funds than were locked by staking.826	// 	// Therefore, if implemented correctly, this error should not occur.827	// 	Self::set_lock_unchecked(828	// 		staker,829	// 		locked_balance830	// 			.checked_sub(&amount)831	// 			.ok_or(ArithmeticError::Underflow)?,832	// 	);833	// 	Ok(())834	// }835836	/// Adds the balance to locked by the pallet.837	///838	/// - `staker`: staker account.839	/// - `amount`: amount of added locked funds.840	fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {841		Self::get_locked_balance(staker)842			.map_or(<BalanceOf<T>>::default(), |l| l.amount)843			.checked_add(&amount)844			.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))845			.ok_or(ArithmeticError::Overflow.into())846	}847848	/// Sets the new state of a balance locked by the pallet.849	///850	/// - `staker`: staker account.851	/// - `amount`: amount of locked funds.852	fn set_lock_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {853		if amount.is_zero() {854			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(855				LOCK_IDENTIFIER,856				&staker,857			);858		} else {859			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::set_lock(860				LOCK_IDENTIFIER,861				staker,862				amount,863				WithdrawReasons::all(),864			)865		}866	}867868	/// Returns the balance locked by the pallet for the staker.869	///870	/// - `staker`: staker account.871	pub fn get_locked_balance(872		staker: impl EncodeLike<T::AccountId>,873	) -> Option<BalanceLock<BalanceOf<T>>> {874		<<T as Config>::Currency as ExtendedLockableCurrency<T::AccountId>>::locks(staker)875			.into_iter()876			.find(|l| l.id == LOCK_IDENTIFIER)877	}878879	/// Returns the total staked balance for the staker.880	///881	/// - `staker`: staker account.882	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {883		let staked = Staked::<T>::iter_prefix((staker,))884			.into_iter()885			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {886				acc + amount887			});888		if staked != <BalanceOf<T>>::default() {889			Some(staked)890		} else {891			None892		}893	}894895	/// Returns all relay block numbers when stake was made,896	/// the amount of the stake.897	///898	/// - `staker`: staker account.899	pub fn total_staked_by_id_per_block(900		staker: impl EncodeLike<T::AccountId>,901	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {902		let mut staked = Staked::<T>::iter_prefix((staker,))903			.into_iter()904			.map(|(block, (amount, _))| (block, amount))905			.collect::<Vec<_>>();906		staked.sort_by_key(|(block, _)| *block);907		if !staked.is_empty() {908			Some(staked)909		} else {910			None911		}912	}913914	/// Returns the total staked balance for the staker.915	/// If `staker` is `None`, returns the total amount staked.916	/// - `staker`: staker account.917	pub fn cross_id_total_staked(staker: Option<T::CrossAccountId>) -> Option<BalanceOf<T>> {918		staker.map_or(Some(<TotalStaked<T>>::get()), |s| {919			Self::total_staked_by_id(s.as_sub())920		})921	}922923	// pub fn cross_id_locked_balance(staker: T::CrossAccountId) -> BalanceOf<T> {924	// 	Self::get_locked_balance(staker.as_sub())925	// 		.map(|l| l.amount)926	// 		.unwrap_or_default()927	// }928929	/// Returns all relay block numbers when stake was made,930	/// the amount of the stake.931	///932	/// - `staker`: staker account.933	pub fn cross_id_total_staked_per_block(934		staker: T::CrossAccountId,935	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {936		Self::total_staked_by_id_per_block(staker.as_sub()).unwrap_or_default()937	}938939	fn recalculate_and_insert_stake(940		staker: &T::AccountId,941		staked_block: T::BlockNumber,942		next_recalc_block: T::BlockNumber,943		base: BalanceOf<T>,944		iters: u32,945		income_acc: &mut BalanceOf<T>,946	) {947		let income = Self::calculate_income(base, iters);948949		base.checked_add(&income).map(|res| {950			<Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));951			*income_acc += income;952		});953	}954955	fn calculate_income<I>(base: I, iters: u32) -> I956	where957		I: EncodeLike<BalanceOf<T>> + Balance,958	{959		let config = <PalletConfiguration<T>>::get();960		let mut income = base;961962		(0..iters).for_each(|_| income += config.interval_income * income);963964		income - base965	}966967	/// Get relay block number rounded down to multiples of config.recalculation_interval.968	/// We need it to reward stakers in integer parts of recalculation_interval969	fn get_current_recalc_block(970		current_relay_block: T::BlockNumber,971		config: &PalletConfiguration<T>,972	) -> T::BlockNumber {973		(current_relay_block / config.recalculation_interval) * config.recalculation_interval974	}975976	fn get_next_calculated_key() -> Option<Vec<u8>> {977		Self::get_next_calculated_record().map(|key| Staked::<T>::hashed_key_for(key))978	}979}980981impl<T: Config> Pallet<T>982where983	<<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum,984{985	/// Returns the amount reserved by the pending.986	/// If `staker` is `None`, returns the total pending.987	///988	/// -`staker`: staker account.989	///990	/// Since user funds are not transferred anywhere by staking, overflow protection is provided991	/// at the level of the associated type `Balance` of `Currency` trait. In order to overflow,992	/// the staker must have more funds on his account than the maximum set for `Balance` type.993	pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {994		staker.map_or(995			PendingUnstake::<T>::iter_values()996				.flat_map(|pendings| pendings.into_iter().map(|(_, amount)| amount))997				.sum(),998			|s| {999				PendingUnstake::<T>::iter_values()1000					.flatten()1001					.filter_map(|(id, amount)| {1002						if id == *s.as_sub() {1003							Some(amount)1004						} else {1005							None1006						}1007					})1008					.sum()1009			},1010		)1011	}10121013	/// Returns all parachain block numbers when unreserve is expected,1014	/// the amount of the unreserved funds.1015	///1016	/// - `staker`: staker account.1017	pub fn cross_id_pending_unstake_per_block(1018		staker: T::CrossAccountId,1019	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1020		let mut unsorted_res = vec![];1021		PendingUnstake::<T>::iter().for_each(|(block, pendings)| {1022			pendings.into_iter().for_each(|(id, amount)| {1023				if id == *staker.as_sub() {1024					unsorted_res.push((block, amount));1025				};1026			})1027		});10281029		unsorted_res.sort_by_key(|(block, _)| *block);1030		unsorted_res1031	}1032}