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