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