difftreelog
feature(app-promo) added `force_unstake` extrinsic
in: master
`on_initialize` now stops unstakes when the Maintainance mode is enabled.
1 file changed
pallets/app-promotion/src/lib.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # App Promotion pallet18//!19//! The pallet implements the mechanics of staking and sponsoring collections/contracts.20//!21//! - [`Config`]22//! - [`Pallet`]23//! - [`Error`]24//! - [`Event`]25//!26//! ## Overview27//! The App Promotion pallet allows fund holders to stake at a certain daily rate of return.28//! The mechanics implemented in the pallet allow it to act as a sponsor for collections / contracts,29//! the list of which is set by the pallet administrator.30//!31//!32//! ## Interface33//! The pallet provides interfaces for funds, collection/contract operations (see [types] module).3435//!36//! ### Dispatchable Functions37//! - [`set_admin_address`][`Pallet::set_admin_address`] - sets an address as the the admin.38//! - [`stake`][`Pallet::stake`] - stakes the amount of native tokens.39//! - [`unstake`][`Pallet::unstake`] - unstakes all stakes.40//! - [`sponsor_collection`][`Pallet::sponsor_collection`] - sets the pallet to be the sponsor for the collection.41//! - [`stop_sponsoring_collection`][`Pallet::stop_sponsoring_collection`] - removes the pallet as the sponsor for the collection.42//! - [`sponsor_contract`][`Pallet::sponsor_contract`] - sets the pallet to be the sponsor for the contract.43//! - [`stop_sponsoring_contract`][`Pallet::stop_sponsoring_contract`] - removes the pallet as the sponsor for the contract.44//! - [`payout_stakers`][`Pallet::payout_stakers`] - recalculates interest for the specified number of stakers.45//!4647// #![recursion_limit = "1024"]48#![cfg_attr(not(feature = "std"), no_std)]4950#[cfg(feature = "runtime-benchmarks")]51mod benchmarking;5253pub mod types;54pub mod weights;5556use sp_std::{57 vec::{Vec},58 vec,59 iter::Sum,60 borrow::ToOwned,61 cell::RefCell,62};63use sp_core::H160;64use codec::EncodeLike;65use pallet_balances::BalanceLock;66pub use types::*;6768use up_data_structs::CollectionId;6970use frame_support::{71 dispatch::{DispatchResult},72 traits::{73 Get, LockableCurrency,74 tokens::Balance,75 fungible::{Inspect, InspectFreeze, Mutate, MutateFreeze},76 },77 ensure, BoundedVec,78};7980use weights::WeightInfo;8182pub use pallet::*;83use pallet_evm::account::CrossAccountId;84use sp_runtime::{85 Perbill,86 traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion, Zero},87 ArithmeticError, DispatchError,88};8990pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";9192const PENDING_LIMIT_PER_BLOCK: u32 = 3;9394type BalanceOf<T> =95 <<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;9697#[frame_support::pallet]98pub mod pallet {99 use super::*;100 use frame_support::{101 Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId, weights::Weight,102 };103 use frame_system::pallet_prelude::*;104 use sp_runtime::DispatchError;105106 #[pallet::config]107 pub trait Config:108 frame_system::Config + pallet_evm::Config + pallet_configuration::Config109 {110 /// Type to interact with the native token111 type Currency: MutateFreeze<Self::AccountId>112 + Mutate<Self::AccountId>113 + ExtendedLockableCurrency<114 Self::AccountId,115 Balance = <<Self as Config>::Currency as Inspect<Self::AccountId>>::Balance,116 >;117118 /// Type for interacting with collections119 type CollectionHandler: CollectionHandler<120 AccountId = Self::AccountId,121 CollectionId = CollectionId,122 >;123124 /// Type for interacting with conrtacts125 type ContractHandler: ContractHandler<AccountId = Self::CrossAccountId, ContractId = H160>;126127 /// `AccountId` for treasury128 type TreasuryAccountId: Get<Self::AccountId>;129130 /// The app's pallet id, used for deriving its sovereign account address.131 #[pallet::constant]132 type PalletId: Get<PalletId>;133134 /// Freeze identifier used by the pallet135 #[pallet::constant]136 type FreezeIdentifier: Get<137 <<Self as Config>::Currency as InspectFreeze<Self::AccountId>>::Id,138 >;139140 /// In relay blocks.141 #[pallet::constant]142 type RecalculationInterval: Get<Self::BlockNumber>;143144 /// In parachain blocks.145 #[pallet::constant]146 type PendingInterval: Get<Self::BlockNumber>;147148 /// Rate of return for interval in blocks defined in `RecalculationInterval`.149 #[pallet::constant]150 type IntervalIncome: Get<Perbill>;151152 /// Decimals for the `Currency`.153 #[pallet::constant]154 type Nominal: Get<BalanceOf<Self>>;155156 /// Weight information for extrinsics in this pallet.157 type WeightInfo: WeightInfo;158159 // The relay block number provider160 type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;161162 /// Events compatible with [`frame_system::Config::Event`].163 type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;164 }165166 #[pallet::pallet]167 pub struct Pallet<T>(_);168169 #[pallet::event]170 #[pallet::generate_deposit(pub(super) fn deposit_event)]171 pub enum Event<T: Config> {172 /// Staking recalculation was performed173 ///174 /// # Arguments175 /// * AccountId: account of the staker.176 /// * Balance : recalculation base177 /// * Balance : total income178 StakingRecalculation(179 /// An recalculated staker180 T::AccountId,181 /// Base on which interest is calculated182 BalanceOf<T>,183 /// Amount of accrued interest184 BalanceOf<T>,185 ),186187 /// Staking was performed188 ///189 /// # Arguments190 /// * AccountId: account of the staker191 /// * Balance : staking amount192 Stake(T::AccountId, BalanceOf<T>),193194 /// Unstaking was performed195 ///196 /// # Arguments197 /// * AccountId: account of the staker198 /// * Balance : unstaking amount199 Unstake(T::AccountId, BalanceOf<T>),200201 /// The admin was set202 ///203 /// # Arguments204 /// * AccountId: account address of the admin205 SetAdmin(T::AccountId),206 }207208 #[pallet::error]209 pub enum Error<T> {210 /// Error due to action requiring admin to be set.211 AdminNotSet,212 /// No permission to perform an action.213 NoPermission,214 /// Insufficient funds to perform an action.215 NotSufficientFunds,216 /// Occurs when a pending unstake cannot be added in this block. PENDING_LIMIT_PER_BLOCK` limits exceeded.217 PendingForBlockOverflow,218 /// The error is due to the fact that the collection/contract must already be sponsored in order to perform the action.219 SponsorNotSet,220 /// Errors caused by insufficient staked balance.221 InsufficientStakedBalance,222 /// Errors caused by incorrect state of a staker in context of the pallet.223 InconsistencyState,224 }225226 /// Stores the total staked amount.227 #[pallet::storage]228 pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;229230 /// Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.231 #[pallet::storage]232 pub type Admin<T: Config> = StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;233234 /// Stores the amount of tokens staked by account in the blocknumber.235 ///236 /// * **Key1** - Staker account.237 /// * **Key2** - Relay block number when the stake was made.238 /// * **(Balance, BlockNumber)** - Balance of the stake.239 /// The number of the relay block in which we must perform the interest recalculation240 #[pallet::storage]241 pub type Staked<T: Config> = StorageNMap<242 Key = (243 Key<Blake2_128Concat, T::AccountId>,244 Key<Twox64Concat, T::BlockNumber>,245 ),246 Value = (BalanceOf<T>, T::BlockNumber),247 QueryKind = ValueQuery,248 >;249250 /// Stores number of stake records for an `Account`.251 ///252 /// * **Key** - Staker account.253 /// * **Value** - Amount of stakes.254 #[pallet::storage]255 pub type StakesPerAccount<T: Config> =256 StorageMap<_, Blake2_128Concat, T::AccountId, u8, ValueQuery>;257258 /// Pending unstake records for an `Account`.259 ///260 /// * **Key** - Staker account.261 /// * **Value** - Amount of stakes.262 #[pallet::storage]263 pub type PendingUnstake<T: Config> = StorageMap<264 _,265 Twox64Concat,266 T::BlockNumber,267 BoundedVec<(T::AccountId, BalanceOf<T>), ConstU32<PENDING_LIMIT_PER_BLOCK>>,268 ValueQuery,269 >;270271 /// Stores a key for record for which the revenue recalculation was performed.272 /// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.273 #[pallet::storage]274 #[pallet::getter(fn get_next_calculated_record)]275 pub type PreviousCalculatedRecord<T: Config> =276 StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;277278 // #[pallet::storage]279 // pub(crate) type UpgradedToFreezes<T: Config> =280 // StorageValue<Value = bool, QueryKind = ValueQuery>;281282 #[pallet::hooks]283 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {284 /// Block overflow is impossible due to the fact that the unstake algorithm in on_initialize285 /// implies the execution of a strictly limited number of relatively lightweight operations.286 /// A separate benchmark has been implemented to scale the weight depending on the number of pendings.287 fn on_initialize(current_block_number: T::BlockNumber) -> Weight288 where289 <T as frame_system::Config>::BlockNumber: From<u32>,290 {291 let block_pending = PendingUnstake::<T>::take(current_block_number);292 let counter = block_pending.len() as u32;293294 if !block_pending.is_empty() {295 block_pending.into_iter().for_each(|(staker, amount)| {296 Self::get_frozen_balance(&staker).map(|b| {297 let new_state = b.checked_sub(&amount).unwrap_or_default();298 Self::set_freeze_unchecked(&staker, new_state);299 });300 });301 }302303 <T as Config>::WeightInfo::on_initialize(counter)304 }305306 // fn on_runtime_upgrade() -> Weight {307 // use scale_info::prelude::collections::HashSet;308 // let mut consumed_weight = Weight::zero();309 // let mut add_weight = |reads, writes, weight| {310 // consumed_weight += T::DbWeight::get().reads_writes(reads, writes);311 // consumed_weight += weight;312 // };313314 // let mut stakes_unstakes = vec![];315316 // if <UpgradedToFreezes<T>>::get() {317 // add_weight(1, 0, Weight::zero());318 // return consumed_weight;319 // } else {320 // add_weight(1, 1, Weight::zero());321 // <UpgradedToFreezes<T>>::set(true);322 // }323 // <Staked<T>>::iter_keys().for_each(|(staker_id, _)| {324 // add_weight(1, 0, Weight::zero());325 // stakes_unstakes.push(staker_id);326 // });327328 // <PendingUnstake<T>>::iter().for_each(|(_, v)| {329 // add_weight(1, 0, Weight::zero());330 // v.into_iter().for_each(|(staker, _)| {331 // stakes_unstakes.push(staker);332 // });333 // });334335 // // filter duplicated id.336 // stakes_unstakes = stakes_unstakes337 // .into_iter()338 // .map(|key| key)339 // .collect::<HashSet<_>>()340 // .into_iter()341 // .collect();342343 // stakes_unstakes344 // .map(|a| (a, <Pallet<T>>::get_locked_balance(&a).amount))345 // .for_each(|(staker, amount)| {346 // <<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(347 // LOCK_IDENTIFIER,348 // &staker,349 // );350 // <<T as Config>::Currency as MutateFreeze<T::AccountId>>::set_freeze(351 // &<T as Config>::FreezeIdentifier::get(),352 // &staker,353 // amount,354 // );355 // add_weight(1, 2, Weight::zero())356 // });357358 // consumed_weight359 // }360361 // #[cfg(feature = "try-runtime")]362 // fn pre_upgrade() -> Result<Vec<u8>, &'static str> {363 // use sp_std::collections::btree_map::BTreeMap;364 // if <UpgradedToFreezes<T>>::get() {365 // return Ok(Default::default());366 // }367 // // Staker -> (total (stakes and unstakes) locked by promotion);368 // let mut pre_state: BTreeMap<T::AccountId, BalanceOf<T>> = BTreeMap::new();369370 // <Staked<T>>::iter().for_each(|((staker, _), (amount, _))| {371 // if let Some(locked_balance) = pre_state.get_mut(&staker) {372 // *locked_balance += amount;373 // } else {374 // pre_state.insert(staker, amount);375 // }376 // });377378 // <PendingUnstake<T>>::iter().for_each(|(_, v)| {379 // v.into_iter().for_each(|(staker, amount)| {380 // if let Some(locked_balance) = pre_state.get_mut(&staker) {381 // *locked_balance += amount;382 // } else {383 // pre_state.insert(staker, amount);384 // }385 // })386 // });387388 // Ok(pre_state.encode())389 // }390391 // #[cfg(feature = "try-runtime")]392 // fn post_upgrade(pre_state: Vec<u8>) -> Result<(), &'static str> {393 // use sp_std::collections::btree_map::BTreeMap;394395 // if <UpgradedToFreezes<T>>::get() {396 // return Ok(());397 // }398399 // let mut is_ok = true;400401 // let pre_state: BTreeMap<T::AccountId, BalanceOf<T>> =402 // Decode::decode(&mut &pre_state[..]).map_err(|_| "failed to decode pre_state")?;403 // for (staker, frozen_by_promo) in pre_state.into_iter() {404 // let storage_freeze_state = <<T as Config>::Currency as InspectFreeze<405 // T::AccountId,406 // >>::balance_frozen(407 // &<T as Config>::FreezeIdentifier::get(), staker408 // );409 // if storage_freeze_state != frozen_by_promo {410 // is_ok = false;411 // log::error!(412 // "Incorrect frozen balance for {:?}. New balance: {:?}. Before runtime upgrade: locked by promo - {:?}",413 // staker, storage_freeze_state, frozen_by_promo414 // );415 // }416417 // if !<Pallet<T>>::get_locked_balance(&staker).amount.is_zero() {418 // is_ok = false;419 // log::error!(420 // "Incorrect(non-zero) locked by app promo balance for {:?}",421 // staker422 // );423 // }424 // }425426 // if is_ok {427 // Ok(())428 // } else {429 // Err("Incorrect balance for some of stakers... See logs")430 // }431 // }432 }433434 #[pallet::call]435 impl<T: Config> Pallet<T>436 where437 T::BlockNumber: From<u32> + Into<u32>,438 <<T as Config>::Currency as Inspect<T::AccountId>>::Balance: Sum + From<u128>,439 {440 /// Sets an address as the the admin.441 ///442 /// # Permissions443 ///444 /// * Sudo445 ///446 /// # Arguments447 ///448 /// * `admin`: account of the new admin.449 #[pallet::call_index(0)]450 #[pallet::weight(<T as Config>::WeightInfo::set_admin_address())]451 pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {452 ensure_root(origin)?;453454 <Admin<T>>::set(Some(admin.as_sub().to_owned()));455456 Self::deposit_event(Event::SetAdmin(admin.as_sub().to_owned()));457458 Ok(())459 }460461 /// Stakes the amount of native tokens.462 /// Sets `amount` to the locked state.463 /// The maximum number of stakes for a staker is 10.464 ///465 /// # Arguments466 ///467 /// * `amount`: in native tokens.468 #[pallet::call_index(1)]469 #[pallet::weight(<T as Config>::WeightInfo::stake())]470 pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {471 let staker_id = ensure_signed(staker)?;472473 ensure!(474 StakesPerAccount::<T>::get(&staker_id) < 10,475 Error::<T>::NoPermission476 );477478 ensure!(479 amount >= <BalanceOf<T>>::from(100u128) * T::Nominal::get(),480 ArithmeticError::Underflow481 );482 let config = <PalletConfiguration<T>>::get();483484 let balance = <<T as Config>::Currency as Inspect<T::AccountId>>::balance(&staker_id);485486 // checks that we can freeze `amount` on the `staker` account.487 ensure!(488 amount489 <= match Self::get_frozen_balance(&staker_id) {490 Some(frozen_by_pallet) => balance491 .checked_sub(&frozen_by_pallet)492 .ok_or(ArithmeticError::Underflow)?,493 None => balance,494 },495 ArithmeticError::Underflow496 );497498 Self::add_freeze_balance(&staker_id, amount)?;499500 let block_number = T::RelayBlockNumberProvider::current_block_number();501502 // Calculation of the number of recalculation periods,503 // after how much the first interest calculation should be performed for the stake504 let recalculate_after_interval: T::BlockNumber =505 if block_number % config.recalculation_interval == 0u32.into() {506 1u32.into()507 } else {508 2u32.into()509 };510511 // Сalculation of the number of the relay block512 // in which it is necessary to accrue remuneration for the stake.513 let recalc_block = (block_number / config.recalculation_interval514 + recalculate_after_interval)515 * config.recalculation_interval;516517 <Staked<T>>::insert((&staker_id, block_number), {518 let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));519 balance_and_recalc_block.0 = balance_and_recalc_block520 .0521 .checked_add(&amount)522 .ok_or(ArithmeticError::Overflow)?;523 balance_and_recalc_block.1 = recalc_block;524 balance_and_recalc_block525 });526527 <TotalStaked<T>>::set(528 <TotalStaked<T>>::get()529 .checked_add(&amount)530 .ok_or(ArithmeticError::Overflow)?,531 );532533 StakesPerAccount::<T>::mutate(&staker_id, |stakes| *stakes += 1);534535 Self::deposit_event(Event::Stake(staker_id, amount));536537 Ok(())538 }539540 /// Unstakes all stakes.541 /// After the end of `PendingInterval` this sum becomes completely542 /// free for further use.543 #[pallet::call_index(2)]544 #[pallet::weight(<T as Config>::WeightInfo::unstake_all())]545 pub fn unstake_all(staker: OriginFor<T>) -> DispatchResult {546 let staker_id = ensure_signed(staker)?;547548 Self::unstake_all_internal(staker_id)549 }550551 /// Unstakes the amount of balance for the staker.552 /// After the end of `PendingInterval` this sum becomes completely553 /// free for further use.554 ///555 /// # Arguments556 ///557 /// * `staker`: staker account.558 /// * `amount`: amount of unstaked funds.559 #[pallet::call_index(8)]560 #[pallet::weight(<T as Config>::WeightInfo::unstake_partial())]561 pub fn unstake_partial(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {562 let staker_id = ensure_signed(staker)?;563564 Self::unstake_partial_internal(staker_id, amount)565 }566567 /// Sets the pallet to be the sponsor for the collection.568 ///569 /// # Permissions570 ///571 /// * Pallet admin572 ///573 /// # Arguments574 ///575 /// * `collection_id`: ID of the collection that will be sponsored by `pallet_id`576 #[pallet::call_index(3)]577 #[pallet::weight(<T as Config>::WeightInfo::sponsor_collection())]578 pub fn sponsor_collection(579 admin: OriginFor<T>,580 collection_id: CollectionId,581 ) -> DispatchResult {582 let admin_id = ensure_signed(admin)?;583 ensure!(584 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,585 Error::<T>::NoPermission586 );587588 T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)589 }590591 /// Removes the pallet as the sponsor for the collection.592 /// Returns [`NoPermission`][`Error::NoPermission`]593 /// if the pallet wasn't the sponsor.594 ///595 /// # Permissions596 ///597 /// * Pallet admin598 ///599 /// # Arguments600 ///601 /// * `collection_id`: ID of the collection that is sponsored by `pallet_id`602 #[pallet::call_index(4)]603 #[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_collection())]604 pub fn stop_sponsoring_collection(605 admin: OriginFor<T>,606 collection_id: CollectionId,607 ) -> DispatchResult {608 let admin_id = ensure_signed(admin)?;609610 ensure!(611 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,612 Error::<T>::NoPermission613 );614615 ensure!(616 T::CollectionHandler::sponsor(collection_id)?.ok_or(<Error<T>>::SponsorNotSet)?617 == Self::account_id(),618 <Error<T>>::NoPermission619 );620 T::CollectionHandler::remove_collection_sponsor(collection_id)621 }622623 /// Sets the pallet to be the sponsor for the contract.624 ///625 /// # Permissions626 ///627 /// * Pallet admin628 ///629 /// # Arguments630 ///631 /// * `contract_id`: the contract address that will be sponsored by `pallet_id`632 #[pallet::call_index(5)]633 #[pallet::weight(<T as Config>::WeightInfo::sponsor_contract())]634 pub fn sponsor_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {635 let admin_id = ensure_signed(admin)?;636637 ensure!(638 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,639 Error::<T>::NoPermission640 );641642 T::ContractHandler::set_sponsor(643 T::CrossAccountId::from_sub(Self::account_id()),644 contract_id,645 )646 }647648 /// Removes the pallet as the sponsor for the contract.649 /// Returns [`NoPermission`][`Error::NoPermission`]650 /// if the pallet wasn't the sponsor.651 ///652 /// # Permissions653 ///654 /// * Pallet admin655 ///656 /// # Arguments657 ///658 /// * `contract_id`: the contract address that is sponsored by `pallet_id`659 #[pallet::call_index(6)]660 #[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_contract())]661 pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {662 let admin_id = ensure_signed(admin)?;663664 ensure!(665 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,666 Error::<T>::NoPermission667 );668669 ensure!(670 T::ContractHandler::sponsor(contract_id)?671 .ok_or(<Error<T>>::SponsorNotSet)?672 .as_sub() == &Self::account_id(),673 <Error<T>>::NoPermission674 );675 T::ContractHandler::remove_contract_sponsor(contract_id)676 }677678 /// Recalculates interest for the specified number of stakers.679 /// If all stakers are not recalculated, the next call of the extrinsic680 /// will continue the recalculation, from those stakers for whom this681 /// was not perform in last call.682 ///683 /// # Permissions684 ///685 /// * Pallet admin686 ///687 /// # Arguments688 ///689 /// * `stakers_number`: the number of stakers for which recalculation will be performed690 #[pallet::call_index(7)]691 #[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]692 pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {693 let admin_id = ensure_signed(admin)?;694695 ensure!(696 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,697 Error::<T>::NoPermission698 );699 let config = <PalletConfiguration<T>>::get();700701 let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);702703 ensure!(704 stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,705 Error::<T>::NoPermission706 );707708 // calculate the number of the current recalculation block,709 // this is necessary in order to understand which stakers we should calculate interest710 let current_recalc_block = Self::get_current_recalc_block(711 T::RelayBlockNumberProvider::current_block_number(),712 &config,713 );714715 // calculate the number of the next recalculation block,716 // this value is set for the stakers to whom the recalculation will be performed717 let next_recalc_block = current_recalc_block + config.recalculation_interval;718719 let mut storage_iterator = Self::get_next_calculated_key()720 .map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));721722 PreviousCalculatedRecord::<T>::set(None);723724 {725 // Address handled in the last payout loop iteration (below)726 let last_id = RefCell::new(None);727 // Block number (as a part of the key) for which calculation was performed in the last payout loop iteration728 let mut last_staked_calculated_block = Default::default();729 // Reward balance for the address in the iteration730 let income_acc = RefCell::new(BalanceOf::<T>::default());731 // Staked balance for the address in the iteration (before stake is recalculated)732 let amount_acc = RefCell::new(BalanceOf::<T>::default());733734 // This closure is used to finalize handling single staker address in each of the two conditions: (1) when we break out of the payout735 // loop because we reached the number of stakes for rewarding, (2) When all stakes by the single address are handled and the payout736 // loop switches to handling the next staker address:737 // 1. Transfer full reward amount to the payee738 // 2. Lock the reward in staking lock739 // 3. Update TotalStaked amount740 // 4. Issue StakingRecalculation event741 let flush_stake = || -> DispatchResult {742 if let Some(last_id) = &*last_id.borrow() {743 if !income_acc.borrow().is_zero() {744 <<T as Config>::Currency as Mutate<T::AccountId>>::transfer(745 &T::TreasuryAccountId::get(),746 last_id,747 *income_acc.borrow(),748 frame_support::traits::tokens::Preservation::Protect,749 )?;750751 Self::add_freeze_balance(last_id, *income_acc.borrow())?;752 <TotalStaked<T>>::try_mutate(|staked| -> DispatchResult {753 *staked = staked754 .checked_add(&*income_acc.borrow())755 .ok_or(ArithmeticError::Overflow)?;756 Ok(())757 })?;758759 Self::deposit_event(Event::StakingRecalculation(760 last_id.clone(),761 *amount_acc.borrow(),762 *income_acc.borrow(),763 ));764 }765766 *income_acc.borrow_mut() = BalanceOf::<T>::default();767 *amount_acc.borrow_mut() = BalanceOf::<T>::default();768 }769 Ok(())770 };771772 // Reward payment loop. Should loop for no more than config.max_stakers_per_calculation773 // iterations in one extrinsic call774 //775 // stakers_number - keeps the remaining number of iterations (staker addresses to handle)776 // next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out777 // income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)778 while let Some((779 (current_id, staked_block),780 (amount, next_recalc_block_for_stake),781 )) = storage_iterator.next()782 {783 // last_id is not equal current_id when we switch to handling a new staker address784 // or just start handling the very first address. In the latter case last_id will be None and785 // flush_stake will do nothing786 if last_id.borrow().as_ref() != Some(¤t_id) {787 if stakers_number > 0 {788 flush_stake()?;789 *last_id.borrow_mut() = Some(current_id.clone());790 stakers_number -= 1;791 }792 // Break out if we reached the address limit793 else {794 if let Some(staker) = &*last_id.borrow() {795 // Save the last calculated record to pick up in the next extrinsic call796 PreviousCalculatedRecord::<T>::set(Some((797 staker.clone(),798 last_staked_calculated_block,799 )));800 }801 break;802 };803 };804805 // Increase accumulated reward for current address and update current staking record, i.e. (address, staked_block) -> amount806 if current_recalc_block >= next_recalc_block_for_stake {807 *amount_acc.borrow_mut() += amount;808 Self::recalculate_and_insert_stake(809 ¤t_id,810 staked_block,811 next_recalc_block,812 amount,813 ((current_recalc_block - next_recalc_block_for_stake)814 / config.recalculation_interval)815 .into() + 1,816 &mut *income_acc.borrow_mut(),817 );818 }819 last_staked_calculated_block = staked_block;820 }821 flush_stake()?;822 }823824 Ok(())825 }826827 /// Migrates lock state into freeze one828 ///829 /// # Permissions830 ///831 /// * Sudo832 ///833 /// # Arguments834 ///835 /// * `origin`: Must be `Signed`.836 /// * `stakers`: Accounts to be upgraded.837 #[pallet::call_index(9)]838 #[pallet::weight(T::DbWeight::get().reads_writes(2, 2) * stakers.len() as u64)]839 pub fn upgrade_accounts(840 origin: OriginFor<T>,841 stakers: Vec<T::AccountId>,842 ) -> DispatchResult {843 ensure_root(origin)?;844845 stakers846 .into_iter()847 .try_for_each(|s| -> Result<_, DispatchError> {848 if let Some(BalanceLock { amount, .. }) = Self::get_locked_balance(&s) {849 if let Some(_) = Self::get_frozen_balance(&s) {850 return Err(Error::<T>::InconsistencyState.into());851 }852853 <<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(854 LOCK_IDENTIFIER,855 &s,856 );857858 Self::set_freeze_with_result(&s, amount)?;859 Ok(())860 } else {861 Ok(())862 }863 })?;864865 Ok(())866 }867 }868}869870impl<T: Config> Pallet<T> {871 /// The account address of the app promotion pot.872 ///873 /// This actually does computation. If you need to keep using it, then make sure you cache the874 /// value and only call this once.875 pub fn account_id() -> T::AccountId {876 T::PalletId::get().into_account_truncating()877 }878879 /// Unstakes the balance for the staker.880 ///881 /// - `staker`: staker account.882 /// - `amount`: amount of unstaked funds.883 fn unstake_partial_internal(884 staker_id: T::AccountId,885 unstaked_balance: BalanceOf<T>,886 ) -> DispatchResult {887 if unstaked_balance == Default::default() {888 return Ok(());889 }890891 let config = <PalletConfiguration<T>>::get();892893 // calculate block number where the sum would be free894 let unpending_block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;895896 let mut pendings = <PendingUnstake<T>>::get(unpending_block);897898 // checks that we can do unstake in the block899 ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);900901 let mut stakes = Staked::<T>::iter_prefix((&staker_id,)).collect::<Vec<_>>();902903 let total_staked = stakes904 .iter()905 .fold(<BalanceOf<T>>::default(), |acc, (_, (balance, _))| {906 acc + *balance907 });908909 ensure!(910 unstaked_balance <= total_staked,911 <Error<T>>::InsufficientStakedBalance912 );913914 <TotalStaked<T>>::set(915 <TotalStaked<T>>::get()916 .checked_sub(&unstaked_balance)917 .ok_or(ArithmeticError::Underflow)?,918 );919920 stakes.sort_by_key(|(block, _)| *block);921922 let mut acc_amount = unstaked_balance;923 let mut will_deleted_stakes_count = 0u8;924925 let changed_stakes = stakes926 .into_iter()927 .map_while(|(block, (balance_per_block, _))| {928 if acc_amount == <BalanceOf<T>>::default() {929 return None;930 }931 if acc_amount < balance_per_block {932 let res = (block, balance_per_block - acc_amount);933 acc_amount = <BalanceOf<T>>::default();934 return Some(res);935 } else {936 acc_amount -= balance_per_block;937 will_deleted_stakes_count += 1;938 return Some((block, <BalanceOf<T>>::default()));939 }940 })941 .collect::<Vec<_>>();942943 pendings944 .try_push((staker_id.clone(), unstaked_balance))945 .map_err(|_| Error::<T>::PendingForBlockOverflow)?;946947 StakesPerAccount::<T>::try_mutate(&staker_id, |stakes| -> DispatchResult {948 *stakes = stakes949 .checked_sub(will_deleted_stakes_count)950 .ok_or(ArithmeticError::Underflow)?;951 Ok(())952 })?;953954 changed_stakes955 .into_iter()956 .for_each(|(staked_block, current_stake_state)| {957 if current_stake_state == Default::default() {958 <Staked<T>>::remove((&staker_id, staked_block));959 } else {960 <Staked<T>>::mutate((&staker_id, staked_block), |(old_stake_state, _)| {961 *old_stake_state = current_stake_state962 });963 }964 });965966 <PendingUnstake<T>>::insert(unpending_block, pendings);967968 Self::deposit_event(Event::Unstake(staker_id, unstaked_balance));969970 Ok(())971 }972973 /// Adds the balance to locked by the pallet.974 ///975 /// - `staker`: staker account.976 /// - `amount`: amount of added locked funds.977 // fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {978 // Self::get_locked_balance(staker)979 // .map_or(<BalanceOf<T>>::default(), |l| l.amount)980 // .checked_add(&amount)981 // .map(|new_lock| Self::set_lock_unchecked(staker, new_lock))982 // .ok_or(ArithmeticError::Overflow.into())983 // }984985 /// Adds the balance to frozen by the pallet.986 ///987 /// - `staker`: staker account.988 /// - `amount`: amount of added frozen funds.989 fn add_freeze_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {990 Self::get_frozen_balance(staker)991 .unwrap_or_default()992 .checked_add(&amount)993 .map(|freeze| Self::set_freeze_with_result(staker, freeze))994 .ok_or::<DispatchError>(ArithmeticError::Overflow.into())?995 }996997 /// Sets the new state of a balance locked by the pallet.998 ///999 /// - `staker`: staker account.1000 /// - `amount`: amount of locked funds.1001 // fn set_lock_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {1002 // if amount.is_zero() {1003 // <<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(1004 // LOCK_IDENTIFIER,1005 // &staker,1006 // );1007 // } else {1008 // <<T as Config>::Currency as LockableCurrency<T::AccountId>>::set_lock(1009 // LOCK_IDENTIFIER,1010 // staker,1011 // amount,1012 // WithdrawReasons::all(),1013 // )1014 // }1015 // }10161017 /// Sets the new state of a balance frozen by the pallet.1018 ///1019 /// - `staker`: staker account.1020 /// - `amount`: amount of frozen funds.1021 fn set_freeze_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {1022 Self::set_freeze_with_result(staker, amount);1023 }10241025 /// Sets the new state of a balance frozen by the pallet.1026 ///1027 /// - `staker`: staker account.1028 /// - `amount`: amount of frozen funds.1029 fn set_freeze_with_result(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {1030 if amount.is_zero() {1031 <<T as Config>::Currency as MutateFreeze<T::AccountId>>::thaw(1032 &T::FreezeIdentifier::get(),1033 &staker,1034 )1035 } else {1036 <<T as Config>::Currency as MutateFreeze<T::AccountId>>::set_freeze(1037 &T::FreezeIdentifier::get(),1038 staker,1039 amount,1040 )1041 }1042 }10431044 /// Returns the balance locked by the pallet for the staker.1045 ///1046 /// - `staker`: staker account.1047 pub fn get_locked_balance(1048 staker: impl EncodeLike<T::AccountId>,1049 ) -> Option<BalanceLock<BalanceOf<T>>> {1050 <<T as Config>::Currency as ExtendedLockableCurrency<T::AccountId>>::locks(staker)1051 .into_iter()1052 .find(|l| l.id == LOCK_IDENTIFIER)1053 }10541055 /// Returns the balance frozen by the pallet for the staker.1056 ///1057 /// - `staker`: staker account.1058 pub fn get_frozen_balance(staker: &T::AccountId) -> Option<BalanceOf<T>> {1059 let res = <<T as Config>::Currency as InspectFreeze<T::AccountId>>::balance_frozen(1060 &T::FreezeIdentifier::get(),1061 staker,1062 );10631064 if res == Zero::zero() {1065 None1066 } else {1067 Some(res)1068 }1069 }10701071 /// Returns the total staked balance for the staker.1072 ///1073 /// - `staker`: staker account.1074 pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {1075 let staked = Staked::<T>::iter_prefix((staker,))1076 .fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {1077 acc + amount1078 });1079 if staked != <BalanceOf<T>>::default() {1080 Some(staked)1081 } else {1082 None1083 }1084 }10851086 /// Returns all relay block numbers when stake was made,1087 /// the amount of the stake.1088 ///1089 /// - `staker`: staker account.1090 pub fn total_staked_by_id_per_block(1091 staker: impl EncodeLike<T::AccountId>,1092 ) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {1093 let mut staked = Staked::<T>::iter_prefix((staker,))1094 .map(|(block, (amount, _))| (block, amount))1095 .collect::<Vec<_>>();1096 staked.sort_by_key(|(block, _)| *block);1097 if !staked.is_empty() {1098 Some(staked)1099 } else {1100 None1101 }1102 }11031104 /// Returns the total staked balance for the staker.1105 /// If `staker` is `None`, returns the total amount staked.1106 /// - `staker`: staker account.1107 pub fn cross_id_total_staked(staker: Option<T::CrossAccountId>) -> Option<BalanceOf<T>> {1108 staker.map_or(Some(<TotalStaked<T>>::get()), |s| {1109 Self::total_staked_by_id(s.as_sub())1110 })1111 }11121113 /// Returns all relay block numbers when stake was made,1114 /// the amount of the stake.1115 ///1116 /// - `staker`: staker account.1117 pub fn cross_id_total_staked_per_block(1118 staker: T::CrossAccountId,1119 ) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1120 Self::total_staked_by_id_per_block(staker.as_sub()).unwrap_or_default()1121 }11221123 fn recalculate_and_insert_stake(1124 staker: &T::AccountId,1125 staked_block: T::BlockNumber,1126 next_recalc_block: T::BlockNumber,1127 base: BalanceOf<T>,1128 iters: u32,1129 income_acc: &mut BalanceOf<T>,1130 ) {1131 let income = Self::calculate_income(base, iters);11321133 base.checked_add(&income).map(|res| {1134 <Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));1135 *income_acc += income;1136 });1137 }11381139 fn calculate_income<I>(base: I, iters: u32) -> I1140 where1141 I: EncodeLike<BalanceOf<T>> + Balance,1142 {1143 let config = <PalletConfiguration<T>>::get();1144 let mut income = base;11451146 (0..iters).for_each(|_| income += config.interval_income * income);11471148 income - base1149 }11501151 /// Get relay block number rounded down to multiples of config.recalculation_interval.1152 /// We need it to reward stakers in integer parts of recalculation_interval1153 fn get_current_recalc_block(1154 current_relay_block: T::BlockNumber,1155 config: &PalletConfiguration<T>,1156 ) -> T::BlockNumber {1157 (current_relay_block / config.recalculation_interval) * config.recalculation_interval1158 }11591160 fn get_next_calculated_key() -> Option<Vec<u8>> {1161 Self::get_next_calculated_record().map(|key| Staked::<T>::hashed_key_for(key))1162 }1163}11641165impl<T: Config> Pallet<T>1166where1167 <<T as Config>::Currency as Inspect<T::AccountId>>::Balance: Sum,1168{1169 /// Returns the amount reserved by the pending.1170 /// If `staker` is `None`, returns the total pending.1171 ///1172 /// -`staker`: staker account.1173 ///1174 /// Since user funds are not transferred anywhere by staking, overflow protection is provided1175 /// at the level of the associated type `Balance` of `Currency` trait. In order to overflow,1176 /// the staker must have more funds on his account than the maximum set for `Balance` type.1177 pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {1178 staker.map_or(1179 PendingUnstake::<T>::iter_values()1180 .flat_map(|pendings| pendings.into_iter().map(|(_, amount)| amount))1181 .sum(),1182 |s| {1183 PendingUnstake::<T>::iter_values()1184 .flatten()1185 .filter_map(|(id, amount)| {1186 if id == *s.as_sub() {1187 Some(amount)1188 } else {1189 None1190 }1191 })1192 .sum()1193 },1194 )1195 }11961197 /// Returns all parachain block numbers when unreserve is expected,1198 /// the amount of the unreserved funds.1199 ///1200 /// - `staker`: staker account.1201 pub fn cross_id_pending_unstake_per_block(1202 staker: T::CrossAccountId,1203 ) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1204 let mut unsorted_res = vec![];1205 PendingUnstake::<T>::iter().for_each(|(block, pendings)| {1206 pendings.into_iter().for_each(|(id, amount)| {1207 if id == *staker.as_sub() {1208 unsorted_res.push((block, amount));1209 };1210 })1211 });12121213 unsorted_res.sort_by_key(|(block, _)| *block);1214 unsorted_res1215 }12161217 fn unstake_all_internal(staker_id: T::AccountId) -> DispatchResult {1218 let config = <PalletConfiguration<T>>::get();12191220 // calculate block number where the sum would be free1221 let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;12221223 let mut pendings = <PendingUnstake<T>>::get(block);12241225 // checks that we can do unstake in the block1226 ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);12271228 let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))1229 .map(|(_, (amount, _))| amount)1230 .sum();12311232 if total_staked.is_zero() {1233 return Ok(());1234 }12351236 pendings1237 .try_push((staker_id.clone(), total_staked))1238 .map_err(|_| Error::<T>::PendingForBlockOverflow)?;12391240 <PendingUnstake<T>>::insert(block, pendings);12411242 TotalStaked::<T>::set(1243 TotalStaked::<T>::get()1244 .checked_sub(&total_staked)1245 .ok_or(ArithmeticError::Underflow)?,1246 );12471248 StakesPerAccount::<T>::remove(&staker_id);12491250 Self::deposit_event(Event::Unstake(staker_id, total_staked));12511252 Ok(())1253 }1254}