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

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	pub struct Pallet<T>(_);156157	#[pallet::event]158	#[pallet::generate_deposit(pub(super) fn deposit_event)]159	pub enum Event<T: Config> {160		/// Staking recalculation was performed161		///162		/// # Arguments163		/// * AccountId: account of the staker.164		/// * Balance : recalculation base165		/// * Balance : total income166		StakingRecalculation(167			/// An recalculated staker168			T::AccountId,169			/// Base on which interest is calculated170			BalanceOf<T>,171			/// Amount of accrued interest172			BalanceOf<T>,173		),174175		/// Staking was performed176		///177		/// # Arguments178		/// * AccountId: account of the staker179		/// * Balance : staking amount180		Stake(T::AccountId, BalanceOf<T>),181182		/// Unstaking was performed183		///184		/// # Arguments185		/// * AccountId: account of the staker186		/// * Balance : unstaking amount187		Unstake(T::AccountId, BalanceOf<T>),188189		/// The admin was set190		///191		/// # Arguments192		/// * AccountId: account address of the admin193		SetAdmin(T::AccountId),194	}195196	#[pallet::error]197	pub enum Error<T> {198		/// Error due to action requiring admin to be set.199		AdminNotSet,200		/// No permission to perform an action.201		NoPermission,202		/// Insufficient funds to perform an action.203		NotSufficientFunds,204		/// Occurs when a pending unstake cannot be added in this block. PENDING_LIMIT_PER_BLOCK` limits exceeded.205		PendingForBlockOverflow,206		/// The error is due to the fact that the collection/contract must already be sponsored in order to perform the action.207		SponsorNotSet,208		/// Errors caused by incorrect actions with a locked balance.209		IncorrectLockedBalanceOperation,210		/// Errors caused by insufficient staked balance.211		InsufficientStakedBalance,212	}213214	/// Stores the total staked amount.215	#[pallet::storage]216	pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;217218	/// Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.219	#[pallet::storage]220	pub type Admin<T: Config> = StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;221222	/// Stores the amount of tokens staked by account in the blocknumber.223	///224	/// * **Key1** - Staker account.225	/// * **Key2** - Relay block number when the stake was made.226	/// * **(Balance, BlockNumber)** - Balance of the stake.227	/// The number of the relay block in which we must perform the interest recalculation228	#[pallet::storage]229	pub type Staked<T: Config> = StorageNMap<230		Key = (231			Key<Blake2_128Concat, T::AccountId>,232			Key<Twox64Concat, T::BlockNumber>,233		),234		Value = (BalanceOf<T>, T::BlockNumber),235		QueryKind = ValueQuery,236	>;237238	/// Stores number of stake records for an `Account`.239	///240	/// * **Key** - Staker account.241	/// * **Value** - Amount of stakes.242	#[pallet::storage]243	pub type StakesPerAccount<T: Config> =244		StorageMap<_, Blake2_128Concat, T::AccountId, u8, ValueQuery>;245246	/// Pending unstake records for an `Account`.247	///248	/// * **Key** - Staker account.249	/// * **Value** - Amount of stakes.250	#[pallet::storage]251	pub type PendingUnstake<T: Config> = StorageMap<252		_,253		Twox64Concat,254		T::BlockNumber,255		BoundedVec<(T::AccountId, BalanceOf<T>), ConstU32<PENDING_LIMIT_PER_BLOCK>>,256		ValueQuery,257	>;258259	/// Stores a key for record for which the revenue recalculation was performed.260	/// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.261	#[pallet::storage]262	#[pallet::getter(fn get_next_calculated_record)]263	pub type PreviousCalculatedRecord<T: Config> =264		StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;265266	#[pallet::storage]267	pub(crate) type UpgradedToReserves<T: Config> =268		StorageValue<Value = bool, QueryKind = ValueQuery>;269270	#[pallet::hooks]271	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {272		/// Block overflow is impossible due to the fact that the unstake algorithm in on_initialize273		/// implies the execution of a strictly limited number of relatively lightweight operations.274		/// A separate benchmark has been implemented to scale the weight depending on the number of pendings.275		fn on_initialize(current_block_number: T::BlockNumber) -> Weight276		where277			<T as frame_system::Config>::BlockNumber: From<u32>,278		{279			let block_pending = PendingUnstake::<T>::take(current_block_number);280			let counter = block_pending.len() as u32;281282			if !block_pending.is_empty() {283				block_pending.into_iter().for_each(|(staker, amount)| {284					Self::get_locked_balance(&staker).map(|b| {285						let new_state = b.amount.checked_sub(&amount).unwrap_or_default();286						Self::set_lock_unchecked(&staker, new_state);287					});288				});289			}290291			<T as Config>::WeightInfo::on_initialize(counter)292		}293294		fn on_runtime_upgrade() -> Weight {295			<UpgradedToReserves<T>>::kill();296297			T::DbWeight::get().reads_writes(0, 1)298		}299	}300301	#[pallet::call]302	impl<T: Config> Pallet<T>303	where304		T::BlockNumber: From<u32> + Into<u32>,305		<<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum + From<u128>,306	{307		/// Sets an address as the the admin.308		///309		/// # Permissions310		///311		/// * Sudo312		///313		/// # Arguments314		///315		/// * `admin`: account of the new admin.316		#[pallet::call_index(0)]317		#[pallet::weight(<T as Config>::WeightInfo::set_admin_address())]318		pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {319			ensure_root(origin)?;320321			<Admin<T>>::set(Some(admin.as_sub().to_owned()));322323			Self::deposit_event(Event::SetAdmin(admin.as_sub().to_owned()));324325			Ok(())326		}327328		/// Stakes the amount of native tokens.329		/// Sets `amount` to the locked state.330		/// The maximum number of stakes for a staker is 10.331		///332		/// # Arguments333		///334		/// * `amount`: in native tokens.335		#[pallet::call_index(1)]336		#[pallet::weight(<T as Config>::WeightInfo::stake())]337		pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {338			let staker_id = ensure_signed(staker)?;339340			ensure!(341				StakesPerAccount::<T>::get(&staker_id) < 10,342				Error::<T>::NoPermission343			);344345			ensure!(346				amount >= <BalanceOf<T>>::from(100u128) * T::Nominal::get(),347				ArithmeticError::Underflow348			);349			let config = <PalletConfiguration<T>>::get();350351			let balance =352				<<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);353354			// checks that we can lock `amount` on the `staker` account.355			ensure!(356				amount357					<= match Self::get_locked_balance(&staker_id) {358						Some(lock) => balance359							.checked_sub(&lock.amount)360							.ok_or(ArithmeticError::Underflow)?,361						None => balance,362					},363				ArithmeticError::Underflow364			);365366			Self::add_lock_balance(&staker_id, amount)?;367368			let block_number = T::RelayBlockNumberProvider::current_block_number();369370			// Calculation of the number of recalculation periods,371			// after how much the first interest calculation should be performed for the stake372			let recalculate_after_interval: T::BlockNumber =373				if block_number % config.recalculation_interval == 0u32.into() {374					1u32.into()375				} else {376					2u32.into()377				};378379			// Сalculation of the number of the relay block380			// in which it is necessary to accrue remuneration for the stake.381			let recalc_block = (block_number / config.recalculation_interval382				+ recalculate_after_interval)383				* config.recalculation_interval;384385			<Staked<T>>::insert((&staker_id, block_number), {386				let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));387				balance_and_recalc_block.0 = balance_and_recalc_block388					.0389					.checked_add(&amount)390					.ok_or(ArithmeticError::Overflow)?;391				balance_and_recalc_block.1 = recalc_block;392				balance_and_recalc_block393			});394395			<TotalStaked<T>>::set(396				<TotalStaked<T>>::get()397					.checked_add(&amount)398					.ok_or(ArithmeticError::Overflow)?,399			);400401			StakesPerAccount::<T>::mutate(&staker_id, |stakes| *stakes += 1);402403			Self::deposit_event(Event::Stake(staker_id, amount));404405			Ok(())406		}407408		/// Unstakes all stakes.409		/// After the end of `PendingInterval` this sum becomes completely410		/// free for further use.411		#[pallet::call_index(2)]412		#[pallet::weight(<T as Config>::WeightInfo::unstake_all())]413		pub fn unstake_all(staker: OriginFor<T>) -> DispatchResult {414			let staker_id = ensure_signed(staker)?;415416			Self::unstake_all_internal(staker_id)417		}418419		/// Unstakes the amount of balance for the staker.420		/// After the end of `PendingInterval` this sum becomes completely421		/// free for further use.422		///423		///  # Arguments424		///425		/// * `staker`: staker account.426		/// * `amount`: amount of unstaked funds.427		#[pallet::call_index(8)]428		#[pallet::weight(<T as Config>::WeightInfo::unstake_partial())]429		pub fn unstake_partial(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {430			let staker_id = ensure_signed(staker)?;431432			Self::unstake_partial_internal(staker_id, amount)433		}434435		/// Sets the pallet to be the sponsor for the collection.436		///437		/// # Permissions438		///439		/// * Pallet admin440		///441		/// # Arguments442		///443		/// * `collection_id`: ID of the collection that will be sponsored by `pallet_id`444		#[pallet::call_index(3)]445		#[pallet::weight(<T as Config>::WeightInfo::sponsor_collection())]446		pub fn sponsor_collection(447			admin: OriginFor<T>,448			collection_id: CollectionId,449		) -> DispatchResult {450			let admin_id = ensure_signed(admin)?;451			ensure!(452				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,453				Error::<T>::NoPermission454			);455456			T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)457		}458459		/// Removes the pallet as the sponsor for the collection.460		/// Returns [`NoPermission`][`Error::NoPermission`]461		/// if the pallet wasn't the sponsor.462		///463		/// # Permissions464		///465		/// * Pallet admin466		///467		/// # Arguments468		///469		/// * `collection_id`: ID of the collection that is sponsored by `pallet_id`470		#[pallet::call_index(4)]471		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_collection())]472		pub fn stop_sponsoring_collection(473			admin: OriginFor<T>,474			collection_id: CollectionId,475		) -> DispatchResult {476			let admin_id = ensure_signed(admin)?;477478			ensure!(479				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,480				Error::<T>::NoPermission481			);482483			ensure!(484				T::CollectionHandler::sponsor(collection_id)?.ok_or(<Error<T>>::SponsorNotSet)?485					== Self::account_id(),486				<Error<T>>::NoPermission487			);488			T::CollectionHandler::remove_collection_sponsor(collection_id)489		}490491		/// Sets the pallet to be the sponsor for the contract.492		///493		/// # Permissions494		///495		/// * Pallet admin496		///497		/// # Arguments498		///499		/// * `contract_id`: the contract address that will be sponsored by `pallet_id`500		#[pallet::call_index(5)]501		#[pallet::weight(<T as Config>::WeightInfo::sponsor_contract())]502		pub fn sponsor_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {503			let admin_id = ensure_signed(admin)?;504505			ensure!(506				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,507				Error::<T>::NoPermission508			);509510			T::ContractHandler::set_sponsor(511				T::CrossAccountId::from_sub(Self::account_id()),512				contract_id,513			)514		}515516		/// Removes the pallet as the sponsor for the contract.517		/// Returns [`NoPermission`][`Error::NoPermission`]518		/// if the pallet wasn't the sponsor.519		///520		/// # Permissions521		///522		/// * Pallet admin523		///524		/// # Arguments525		///526		/// * `contract_id`: the contract address that is sponsored by `pallet_id`527		#[pallet::call_index(6)]528		#[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_contract())]529		pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {530			let admin_id = ensure_signed(admin)?;531532			ensure!(533				admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,534				Error::<T>::NoPermission535			);536537			ensure!(538				T::ContractHandler::sponsor(contract_id)?539					.ok_or(<Error<T>>::SponsorNotSet)?540					.as_sub() == &Self::account_id(),541				<Error<T>>::NoPermission542			);543			T::ContractHandler::remove_contract_sponsor(contract_id)544		}545546		/// Recalculates interest for the specified number of stakers.547		/// If all stakers are not recalculated, the next call of the extrinsic548		/// will continue the recalculation, from those stakers for whom this549		/// was not perform in last call.550		///551		/// # Permissions552		///553		/// * Pallet admin554		///555		/// # Arguments556		///557		/// * `stakers_number`: the number of stakers for which recalculation will be performed558		#[pallet::call_index(7)]559		#[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]560		pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> 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			);567			let config = <PalletConfiguration<T>>::get();568569			let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);570571			ensure!(572				stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,573				Error::<T>::NoPermission574			);575576			// calculate the number of the current recalculation block,577			// this is necessary in order to understand which stakers we should calculate interest578			let current_recalc_block = Self::get_current_recalc_block(579				T::RelayBlockNumberProvider::current_block_number(),580				&config,581			);582583			// calculate the number of the next recalculation block,584			// this value is set for the stakers to whom the recalculation will be performed585			let next_recalc_block = current_recalc_block + config.recalculation_interval;586587			let mut storage_iterator = Self::get_next_calculated_key()588				.map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));589590			PreviousCalculatedRecord::<T>::set(None);591592			{593				// Address handled in the last payout loop iteration (below)594				let last_id = RefCell::new(None);595				// Block number (as a part of the key) for which calculation was performed in the last payout loop iteration596				let mut last_staked_calculated_block = Default::default();597				// Reward balance for the address in the iteration598				let income_acc = RefCell::new(BalanceOf::<T>::default());599				// Staked balance for the address in the iteration (before stake is recalculated)600				let amount_acc = RefCell::new(BalanceOf::<T>::default());601602				// This closure is used to finalize handling single staker address in each of the two conditions: (1) when we break out of the payout603				// loop because we reached the number of stakes for rewarding, (2) When all stakes by the single address are handled and the payout604				// loop switches to handling the next staker address:605				//   1. Transfer full reward amount to the payee606				//   2. Lock the reward in staking lock607				//   3. Update TotalStaked amount608				//   4. Issue StakingRecalculation event609				let flush_stake = || -> DispatchResult {610					if let Some(last_id) = &*last_id.borrow() {611						if !income_acc.borrow().is_zero() {612							<<T as Config>::Currency as Currency<T::AccountId>>::transfer(613								&T::TreasuryAccountId::get(),614								last_id,615								*income_acc.borrow(),616								ExistenceRequirement::KeepAlive,617							)?;618619							Self::add_lock_balance(last_id, *income_acc.borrow())?;620							<TotalStaked<T>>::try_mutate(|staked| -> DispatchResult {621								*staked = staked622									.checked_add(&*income_acc.borrow())623									.ok_or(ArithmeticError::Overflow)?;624								Ok(())625							})?;626627							Self::deposit_event(Event::StakingRecalculation(628								last_id.clone(),629								*amount_acc.borrow(),630								*income_acc.borrow(),631							));632						}633634						*income_acc.borrow_mut() = BalanceOf::<T>::default();635						*amount_acc.borrow_mut() = BalanceOf::<T>::default();636					}637					Ok(())638				};639640				// Reward payment loop. Should loop for no more than config.max_stakers_per_calculation641				// iterations in one extrinsic call642				//643				// stakers_number - keeps the remaining number of iterations (staker addresses to handle)644				// next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out645				// income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)646				while let Some((647					(current_id, staked_block),648					(amount, next_recalc_block_for_stake),649				)) = storage_iterator.next()650				{651					// last_id is not equal current_id when we switch to handling a new staker address652					// or just start handling the very first address. In the latter case last_id will be None and653					// flush_stake will do nothing654					if last_id.borrow().as_ref() != Some(&current_id) {655						if stakers_number > 0 {656							flush_stake()?;657							*last_id.borrow_mut() = Some(current_id.clone());658							stakers_number -= 1;659						}660						// Break out if we reached the address limit661						else {662							if let Some(staker) = &*last_id.borrow() {663								// Save the last calculated record to pick up in the next extrinsic call664								PreviousCalculatedRecord::<T>::set(Some((665									staker.clone(),666									last_staked_calculated_block,667								)));668							}669							break;670						};671					};672673					// Increase accumulated reward for current address and update current staking record, i.e. (address, staked_block) -> amount674					if current_recalc_block >= next_recalc_block_for_stake {675						*amount_acc.borrow_mut() += amount;676						Self::recalculate_and_insert_stake(677							&current_id,678							staked_block,679							next_recalc_block,680							amount,681							((current_recalc_block - next_recalc_block_for_stake)682								/ config.recalculation_interval)683								.into() + 1,684							&mut *income_acc.borrow_mut(),685						);686					}687					last_staked_calculated_block = staked_block;688				}689				flush_stake()?;690			}691692			Ok(())693		}694	}695}696697impl<T: Config> Pallet<T> {698	/// The account address of the app promotion pot.699	///700	/// This actually does computation. If you need to keep using it, then make sure you cache the701	/// value and only call this once.702	pub fn account_id() -> T::AccountId {703		T::PalletId::get().into_account_truncating()704	}705706	/// Unstakes the balance for the staker.707	///708	/// - `staker`: staker account.709	/// - `amount`: amount of unstaked funds.710	fn unstake_partial_internal(711		staker_id: T::AccountId,712		unstaked_balance: BalanceOf<T>,713	) -> DispatchResult {714		if unstaked_balance == Default::default() {715			return Ok(());716		}717718		let config = <PalletConfiguration<T>>::get();719720		// calculate block number where the sum would be free721		let unpending_block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;722723		let mut pendings = <PendingUnstake<T>>::get(unpending_block);724725		// checks that we can do unstake in the block726		ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);727728		let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();729730		let total_staked = stakes731			.iter()732			.fold(<BalanceOf<T>>::default(), |acc, (_, (balance, _))| {733				acc + *balance734			});735736		ensure!(737			unstaked_balance <= total_staked,738			<Error<T>>::InsufficientStakedBalance739		);740741		<TotalStaked<T>>::set(742			<TotalStaked<T>>::get()743				.checked_sub(&unstaked_balance)744				.ok_or(ArithmeticError::Underflow)?,745		);746747		stakes.sort_by_key(|(block, _)| *block);748749		let mut acc_amount = unstaked_balance;750		let mut will_deleted_stakes_count = 0u8;751752		let changed_stakes = stakes753			.into_iter()754			.map_while(|(block, (balance_per_block, _))| {755				if acc_amount == <BalanceOf<T>>::default() {756					return None;757				}758				if acc_amount < balance_per_block {759					let res = (block, balance_per_block - acc_amount);760					acc_amount = <BalanceOf<T>>::default();761					return Some(res);762				} else {763					acc_amount -= balance_per_block;764					will_deleted_stakes_count += 1;765					return Some((block, <BalanceOf<T>>::default()));766				}767			})768			.collect::<Vec<_>>();769770		pendings771			.try_push((staker_id.clone(), unstaked_balance))772			.map_err(|_| Error::<T>::PendingForBlockOverflow)?;773774		StakesPerAccount::<T>::try_mutate(&staker_id, |stakes| -> DispatchResult {775			*stakes = stakes776				.checked_sub(will_deleted_stakes_count)777				.ok_or(ArithmeticError::Underflow)?;778			Ok(())779		})?;780781		changed_stakes782			.into_iter()783			.for_each(|(staked_block, current_stake_state)| {784				if current_stake_state == Default::default() {785					<Staked<T>>::remove((&staker_id, staked_block));786				} else {787					<Staked<T>>::mutate((&staker_id, staked_block), |(old_stake_state, _)| {788						*old_stake_state = current_stake_state789					});790				}791			});792793		<PendingUnstake<T>>::insert(unpending_block, pendings);794795		Self::deposit_event(Event::Unstake(staker_id, unstaked_balance));796797		Ok(())798	}799800	/// Adds the balance to locked by the pallet.801	///802	/// - `staker`: staker account.803	/// - `amount`: amount of added locked funds.804	fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {805		Self::get_locked_balance(staker)806			.map_or(<BalanceOf<T>>::default(), |l| l.amount)807			.checked_add(&amount)808			.map(|new_lock| Self::set_lock_unchecked(staker, new_lock))809			.ok_or(ArithmeticError::Overflow.into())810	}811812	/// Sets the new state of a balance locked by the pallet.813	///814	/// - `staker`: staker account.815	/// - `amount`: amount of locked funds.816	fn set_lock_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {817		if amount.is_zero() {818			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(819				LOCK_IDENTIFIER,820				&staker,821			);822		} else {823			<<T as Config>::Currency as LockableCurrency<T::AccountId>>::set_lock(824				LOCK_IDENTIFIER,825				staker,826				amount,827				WithdrawReasons::all(),828			)829		}830	}831832	/// Returns the balance locked by the pallet for the staker.833	///834	/// - `staker`: staker account.835	pub fn get_locked_balance(836		staker: impl EncodeLike<T::AccountId>,837	) -> Option<BalanceLock<BalanceOf<T>>> {838		<<T as Config>::Currency as ExtendedLockableCurrency<T::AccountId>>::locks(staker)839			.into_iter()840			.find(|l| l.id == LOCK_IDENTIFIER)841	}842843	/// Returns the total staked balance for the staker.844	///845	/// - `staker`: staker account.846	pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {847		let staked = Staked::<T>::iter_prefix((staker,))848			.fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {849				acc + amount850			});851		if staked != <BalanceOf<T>>::default() {852			Some(staked)853		} else {854			None855		}856	}857858	/// Returns all relay block numbers when stake was made,859	/// the amount of the stake.860	///861	/// - `staker`: staker account.862	pub fn total_staked_by_id_per_block(863		staker: impl EncodeLike<T::AccountId>,864	) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {865		let mut staked = Staked::<T>::iter_prefix((staker,))866			.map(|(block, (amount, _))| (block, amount))867			.collect::<Vec<_>>();868		staked.sort_by_key(|(block, _)| *block);869		if !staked.is_empty() {870			Some(staked)871		} else {872			None873		}874	}875876	/// Returns the total staked balance for the staker.877	/// If `staker` is `None`, returns the total amount staked.878	/// - `staker`: staker account.879	pub fn cross_id_total_staked(staker: Option<T::CrossAccountId>) -> Option<BalanceOf<T>> {880		staker.map_or(Some(<TotalStaked<T>>::get()), |s| {881			Self::total_staked_by_id(s.as_sub())882		})883	}884885	/// Returns all relay block numbers when stake was made,886	/// the amount of the stake.887	///888	/// - `staker`: staker account.889	pub fn cross_id_total_staked_per_block(890		staker: T::CrossAccountId,891	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {892		Self::total_staked_by_id_per_block(staker.as_sub()).unwrap_or_default()893	}894895	fn recalculate_and_insert_stake(896		staker: &T::AccountId,897		staked_block: T::BlockNumber,898		next_recalc_block: T::BlockNumber,899		base: BalanceOf<T>,900		iters: u32,901		income_acc: &mut BalanceOf<T>,902	) {903		let income = Self::calculate_income(base, iters);904905		base.checked_add(&income).map(|res| {906			<Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));907			*income_acc += income;908		});909	}910911	fn calculate_income<I>(base: I, iters: u32) -> I912	where913		I: EncodeLike<BalanceOf<T>> + Balance,914	{915		let config = <PalletConfiguration<T>>::get();916		let mut income = base;917918		(0..iters).for_each(|_| income += config.interval_income * income);919920		income - base921	}922923	/// Get relay block number rounded down to multiples of config.recalculation_interval.924	/// We need it to reward stakers in integer parts of recalculation_interval925	fn get_current_recalc_block(926		current_relay_block: T::BlockNumber,927		config: &PalletConfiguration<T>,928	) -> T::BlockNumber {929		(current_relay_block / config.recalculation_interval) * config.recalculation_interval930	}931932	fn get_next_calculated_key() -> Option<Vec<u8>> {933		Self::get_next_calculated_record().map(|key| Staked::<T>::hashed_key_for(key))934	}935}936937impl<T: Config> Pallet<T>938where939	<<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum,940{941	/// Returns the amount reserved by the pending.942	/// If `staker` is `None`, returns the total pending.943	///944	/// -`staker`: staker account.945	///946	/// Since user funds are not transferred anywhere by staking, overflow protection is provided947	/// at the level of the associated type `Balance` of `Currency` trait. In order to overflow,948	/// the staker must have more funds on his account than the maximum set for `Balance` type.949	pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {950		staker.map_or(951			PendingUnstake::<T>::iter_values()952				.flat_map(|pendings| pendings.into_iter().map(|(_, amount)| amount))953				.sum(),954			|s| {955				PendingUnstake::<T>::iter_values()956					.flatten()957					.filter_map(|(id, amount)| {958						if id == *s.as_sub() {959							Some(amount)960						} else {961							None962						}963					})964					.sum()965			},966		)967	}968969	/// Returns all parachain block numbers when unreserve is expected,970	/// the amount of the unreserved funds.971	///972	/// - `staker`: staker account.973	pub fn cross_id_pending_unstake_per_block(974		staker: T::CrossAccountId,975	) -> Vec<(T::BlockNumber, BalanceOf<T>)> {976		let mut unsorted_res = vec![];977		PendingUnstake::<T>::iter().for_each(|(block, pendings)| {978			pendings.into_iter().for_each(|(id, amount)| {979				if id == *staker.as_sub() {980					unsorted_res.push((block, amount));981				};982			})983		});984985		unsorted_res.sort_by_key(|(block, _)| *block);986		unsorted_res987	}988989	fn unstake_all_internal(staker_id: T::AccountId) -> DispatchResult {990		let config = <PalletConfiguration<T>>::get();991992		// calculate block number where the sum would be free993		let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;994995		let mut pendings = <PendingUnstake<T>>::get(block);996997		// checks that we can do unstake in the block998		ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);9991000		let mut total_stakes = 0u64;10011002		let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))1003			.map(|(_, (amount, _))| {1004				total_stakes += 1;1005				amount1006			})1007			.sum();10081009		if total_staked.is_zero() {1010			return Ok(());1011		}10121013		pendings1014			.try_push((staker_id.clone(), total_staked))1015			.map_err(|_| Error::<T>::PendingForBlockOverflow)?;10161017		<PendingUnstake<T>>::insert(block, pendings);10181019		TotalStaked::<T>::set(1020			TotalStaked::<T>::get()1021				.checked_sub(&total_staked)1022				.ok_or(ArithmeticError::Underflow)?,1023		);10241025		StakesPerAccount::<T>::remove(&staker_id);10261027		Self::deposit_event(Event::Unstake(staker_id, total_staked));10281029		Ok(())1030	}1031}