difftreelog
feat(app-promo) added impl for `unstake_partial`
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, BoundedVec,76};7778use weights::WeightInfo;7980pub use pallet::*;81use pallet_evm::account::CrossAccountId;82use sp_runtime::{83 Perbill,84 traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion, Zero},85 ArithmeticError,86};8788pub const LOCK_IDENTIFIER: [u8; 8] = *b"appstake";8990const PENDING_LIMIT_PER_BLOCK: u32 = 3;9192type BalanceOf<T> =93 <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;9495#[frame_support::pallet]96pub mod pallet {97 use super::*;98 use frame_support::{99 Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId,100 traits::ReservableCurrency, weights::Weight,101 };102 use frame_system::pallet_prelude::*;103104 #[pallet::config]105 pub trait Config:106 frame_system::Config + pallet_evm::Config + pallet_configuration::Config107 {108 /// Type to interact with the native token109 type Currency: ExtendedLockableCurrency<Self::AccountId>110 + ReservableCurrency<Self::AccountId>;111112 /// Type for interacting with collections113 type CollectionHandler: CollectionHandler<114 AccountId = Self::AccountId,115 CollectionId = CollectionId,116 >;117118 /// Type for interacting with conrtacts119 type ContractHandler: ContractHandler<AccountId = Self::CrossAccountId, ContractId = H160>;120121 /// `AccountId` for treasury122 type TreasuryAccountId: Get<Self::AccountId>;123124 /// The app's pallet id, used for deriving its sovereign account address.125 #[pallet::constant]126 type PalletId: Get<PalletId>;127128 /// In relay blocks.129 #[pallet::constant]130 type RecalculationInterval: Get<Self::BlockNumber>;131132 /// In parachain blocks.133 #[pallet::constant]134 type PendingInterval: Get<Self::BlockNumber>;135136 /// Rate of return for interval in blocks defined in `RecalculationInterval`.137 #[pallet::constant]138 type IntervalIncome: Get<Perbill>;139140 /// Decimals for the `Currency`.141 #[pallet::constant]142 type Nominal: Get<BalanceOf<Self>>;143144 /// Weight information for extrinsics in this pallet.145 type WeightInfo: WeightInfo;146147 // The relay block number provider148 type RelayBlockNumberProvider: BlockNumberProvider<BlockNumber = Self::BlockNumber>;149150 /// Events compatible with [`frame_system::Config::Event`].151 type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;152 }153154 #[pallet::pallet]155 #[pallet::generate_store(pub(super) trait Store)]156 pub struct Pallet<T>(_);157158 #[pallet::event]159 #[pallet::generate_deposit(fn deposit_event)]160 pub enum Event<T: Config> {161 /// Staking recalculation was performed162 ///163 /// # Arguments164 /// * AccountId: account of the staker.165 /// * Balance : recalculation base166 /// * Balance : total income167 StakingRecalculation(168 /// An recalculated staker169 T::AccountId,170 /// Base on which interest is calculated171 BalanceOf<T>,172 /// Amount of accrued interest173 BalanceOf<T>,174 ),175176 /// Staking was performed177 ///178 /// # Arguments179 /// * AccountId: account of the staker180 /// * Balance : staking amount181 Stake(T::AccountId, BalanceOf<T>),182183 /// Unstaking was performed184 ///185 /// # Arguments186 /// * AccountId: account of the staker187 /// * Balance : unstaking amount188 Unstake(T::AccountId, BalanceOf<T>),189190 /// The admin was set191 ///192 /// # Arguments193 /// * AccountId: account address of the admin194 SetAdmin(T::AccountId),195 }196197 #[pallet::error]198 pub enum Error<T> {199 /// Error due to action requiring admin to be set.200 AdminNotSet,201 /// No permission to perform an action.202 NoPermission,203 /// Insufficient funds to perform an action.204 NotSufficientFunds,205 /// Occurs when a pending unstake cannot be added in this block. PENDING_LIMIT_PER_BLOCK` limits exceeded.206 PendingForBlockOverflow,207 /// The error is due to the fact that the collection/contract must already be sponsored in order to perform the action.208 SponsorNotSet,209 /// Errors caused by incorrect actions with a locked balance.210 IncorrectLockedBalanceOperation,211 }212213 /// Stores the total staked amount.214 #[pallet::storage]215 pub type TotalStaked<T: Config> = StorageValue<Value = BalanceOf<T>, QueryKind = ValueQuery>;216217 /// Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.218 #[pallet::storage]219 pub type Admin<T: Config> = StorageValue<Value = T::AccountId, QueryKind = OptionQuery>;220221 /// Stores the amount of tokens staked by account in the blocknumber.222 ///223 /// * **Key1** - Staker account.224 /// * **Key2** - Relay block number when the stake was made.225 /// * **(Balance, BlockNumber)** - Balance of the stake.226 /// The number of the relay block in which we must perform the interest recalculation227 #[pallet::storage]228 pub type Staked<T: Config> = StorageNMap<229 Key = (230 Key<Blake2_128Concat, T::AccountId>,231 Key<Twox64Concat, T::BlockNumber>,232 ),233 Value = (BalanceOf<T>, T::BlockNumber),234 QueryKind = ValueQuery,235 >;236237 /// Stores number of stake records for an `Account`.238 ///239 /// * **Key** - Staker account.240 /// * **Value** - Amount of stakes.241 #[pallet::storage]242 pub type StakesPerAccount<T: Config> =243 StorageMap<_, Blake2_128Concat, T::AccountId, u8, ValueQuery>;244245 /// Pending unstake records for an `Account`.246 ///247 /// * **Key** - Staker account.248 /// * **Value** - Amount of stakes.249 #[pallet::storage]250 pub type PendingUnstake<T: Config> = StorageMap<251 _,252 Twox64Concat,253 T::BlockNumber,254 BoundedVec<(T::AccountId, BalanceOf<T>), ConstU32<PENDING_LIMIT_PER_BLOCK>>,255 ValueQuery,256 >;257258 /// Stores a key for record for which the revenue recalculation was performed.259 /// If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.260 #[pallet::storage]261 #[pallet::getter(fn get_next_calculated_record)]262 pub type PreviousCalculatedRecord<T: Config> =263 StorageValue<Value = (T::AccountId, T::BlockNumber), QueryKind = OptionQuery>;264265 #[pallet::storage]266 pub(crate) type UpgradedToReserves<T: Config> =267 StorageValue<Value = bool, QueryKind = ValueQuery>;268269 #[pallet::hooks]270 impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {271 /// Block overflow is impossible due to the fact that the unstake algorithm in on_initialize272 /// implies the execution of a strictly limited number of relatively lightweight operations.273 /// A separate benchmark has been implemented to scale the weight depending on the number of pendings.274 fn on_initialize(current_block_number: T::BlockNumber) -> Weight275 where276 <T as frame_system::Config>::BlockNumber: From<u32>,277 {278 let block_pending = PendingUnstake::<T>::take(current_block_number);279 let counter = block_pending.len() as u32;280281 if !block_pending.is_empty() {282 block_pending.into_iter().for_each(|(staker, amount)| {283 Self::get_locked_balance(&staker).map(|b| {284 let new_state = b.amount.checked_sub(&amount).unwrap_or_default();285 Self::set_lock_unchecked(&staker, new_state);286 });287 });288 }289290 <T as Config>::WeightInfo::on_initialize(counter)291 }292293 fn on_runtime_upgrade() -> Weight {294 let mut consumed_weight = Weight::zero();295 let mut add_weight = |reads, writes, weight| {296 consumed_weight += T::DbWeight::get().reads_writes(reads, writes);297 consumed_weight += weight;298 };299300 if <UpgradedToReserves<T>>::get() {301 add_weight(1, 0, Weight::zero());302 return consumed_weight;303 } else {304 add_weight(1, 1, Weight::zero());305 <UpgradedToReserves<T>>::set(true);306 }307 <PendingUnstake<T>>::drain().for_each(|(_, v)| {308 add_weight(1, 1, Weight::zero());309 v.into_iter().for_each(|(staker, amount)| {310 <<T as Config>::Currency as ReservableCurrency<T::AccountId>>::unreserve(311 &staker, amount,312 );313 add_weight(1, 1, Weight::zero());314 });315 });316317 consumed_weight318 }319320 #[cfg(feature = "try-runtime")]321 fn pre_upgrade() -> Result<Vec<u8>, &'static str> {322 use sp_std::collections::btree_map::BTreeMap;323 if <UpgradedToReserves<T>>::get() {324 return Ok(Default::default());325 }326 // Staker -> (total amount of reserved balance, reserved by promotion);327 let mut pre_state: BTreeMap<T::AccountId, (BalanceOf<T>, BalanceOf<T>)> =328 BTreeMap::new();329330 <PendingUnstake<T>>::iter().for_each(|(_, v)| {331 v.into_iter().for_each(|(staker, amount)| {332 if let Some((_, reserved_balance)) = pre_state.get_mut(&staker) {333 *reserved_balance += amount;334 } else {335 let total_reserve = <<T as Config>::Currency as ReservableCurrency<336 T::AccountId,337 >>::reserved_balance(&staker);338 pre_state.insert(staker, (total_reserve, amount));339 }340 })341 });342343 Ok(pre_state.encode())344 }345346 #[cfg(feature = "try-runtime")]347 fn post_upgrade(pre_state: Vec<u8>) -> Result<(), &'static str> {348 use sp_std::collections::btree_map::BTreeMap;349350 if <UpgradedToReserves<T>>::get() {351 return Ok(());352 }353354 ensure!(355 <PendingUnstake<T>>::iter().collect::<Vec<_>>().len() == 0,356 "pendingUnstake storage isn't empty"357 );358359 let mut is_ok = true;360361 let pre_state: BTreeMap<T::AccountId, (BalanceOf<T>, BalanceOf<T>)> =362 Decode::decode(&mut &pre_state[..]).map_err(|_| "failed to decode pre_state")?;363 for (staker, (total_reserved, reserved_by_promo)) in pre_state.into_iter() {364 let new_state_reserve = <<T as Config>::Currency as ReservableCurrency<365 T::AccountId,366 >>::reserved_balance(&staker);367 if new_state_reserve != total_reserved - reserved_by_promo {368 is_ok = false;369 log::error!(370 "Incorrect reserved balance for {:?}. New balance: {:?}. Before runtime upgrade: total reserve - {:?}, reserved by promo - {:?}",371 staker, new_state_reserve, total_reserved, reserved_by_promo372 );373 }374 }375376 if is_ok {377 Ok(())378 } else {379 Err("Incorrect balance for some of stakers... See logs")380 }381 }382 }383384 #[pallet::call]385 impl<T: Config> Pallet<T>386 where387 T::BlockNumber: From<u32> + Into<u32>,388 <<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum + From<u128>,389 {390 /// Sets an address as the the admin.391 ///392 /// # Permissions393 ///394 /// * Sudo395 ///396 /// # Arguments397 ///398 /// * `admin`: account of the new admin.399 #[pallet::call_index(0)]400 #[pallet::weight(<T as Config>::WeightInfo::set_admin_address())]401 pub fn set_admin_address(origin: OriginFor<T>, admin: T::CrossAccountId) -> DispatchResult {402 ensure_root(origin)?;403404 <Admin<T>>::set(Some(admin.as_sub().to_owned()));405406 Self::deposit_event(Event::SetAdmin(admin.as_sub().to_owned()));407408 Ok(())409 }410411 /// Stakes the amount of native tokens.412 /// Sets `amount` to the locked state.413 /// The maximum number of stakes for a staker is 10.414 ///415 /// # Arguments416 ///417 /// * `amount`: in native tokens.418 #[pallet::call_index(1)]419 #[pallet::weight(<T as Config>::WeightInfo::stake())]420 pub fn stake(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {421 let staker_id = ensure_signed(staker)?;422423 ensure!(424 StakesPerAccount::<T>::get(&staker_id) < 10,425 Error::<T>::NoPermission426 );427428 ensure!(429 amount >= <BalanceOf<T>>::from(100u128) * T::Nominal::get(),430 ArithmeticError::Underflow431 );432 let config = <PalletConfiguration<T>>::get();433434 let balance =435 <<T as Config>::Currency as Currency<T::AccountId>>::free_balance(&staker_id);436437 // checks that we can lock `amount` on the `staker` account.438 ensure!(439 amount440 <= match Self::get_locked_balance(&staker_id) {441 Some(lock) => balance442 .checked_sub(&lock.amount)443 .ok_or(ArithmeticError::Underflow)?,444 None => balance,445 },446 ArithmeticError::Underflow447 );448449 Self::add_lock_balance(&staker_id, amount)?;450451 let block_number = T::RelayBlockNumberProvider::current_block_number();452453 // Calculation of the number of recalculation periods,454 // after how much the first interest calculation should be performed for the stake455 let recalculate_after_interval: T::BlockNumber =456 if block_number % config.recalculation_interval == 0u32.into() {457 1u32.into()458 } else {459 2u32.into()460 };461462 // Сalculation of the number of the relay block463 // in which it is necessary to accrue remuneration for the stake.464 let recalc_block = (block_number / config.recalculation_interval465 + recalculate_after_interval)466 * config.recalculation_interval;467468 <Staked<T>>::insert((&staker_id, block_number), {469 let mut balance_and_recalc_block = <Staked<T>>::get((&staker_id, block_number));470 balance_and_recalc_block.0 = balance_and_recalc_block471 .0472 .checked_add(&amount)473 .ok_or(ArithmeticError::Overflow)?;474 balance_and_recalc_block.1 = recalc_block;475 balance_and_recalc_block476 });477478 <TotalStaked<T>>::set(479 <TotalStaked<T>>::get()480 .checked_add(&amount)481 .ok_or(ArithmeticError::Overflow)?,482 );483484 StakesPerAccount::<T>::mutate(&staker_id, |stakes| *stakes += 1);485486 Self::deposit_event(Event::Stake(staker_id, amount));487488 Ok(())489 }490491 /// Unstakes all stakes.492 /// Moves the sum of all stakes to the `reserved` state.493 /// After the end of `PendingInterval` this sum becomes completely494 /// free for further use.495 #[pallet::call_index(2)]496 #[pallet::weight(<T as Config>::WeightInfo::unstake())]497 pub fn unstake_all(staker: OriginFor<T>) -> DispatchResultWithPostInfo {498 let staker_id = ensure_signed(staker)?;499 let config = <PalletConfiguration<T>>::get();500501 // calculate block number where the sum would be free502 let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;503504 let mut pendings = <PendingUnstake<T>>::get(block);505506 // checks that we can do unreserve stakes in the block507 ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);508509 let mut total_stakes = 0u64;510511 let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))512 .map(|(_, (amount, _))| {513 total_stakes += 1;514 amount515 })516 .sum();517518 if total_staked.is_zero() {519 return Ok(None::<Weight>.into()); // TO-DO520 }521522 pendings523 .try_push((staker_id.clone(), total_staked))524 .map_err(|_| Error::<T>::PendingForBlockOverflow)?;525526 <PendingUnstake<T>>::insert(block, pendings);527528 TotalStaked::<T>::set(529 TotalStaked::<T>::get()530 .checked_sub(&total_staked)531 .ok_or(ArithmeticError::Underflow)?,532 );533534 StakesPerAccount::<T>::remove(&staker_id);535536 Self::deposit_event(Event::Unstake(staker_id, total_staked));537538 Ok(None::<Weight>.into())539 }540541 /// Unstakes all stakes.542 /// Moves the sum of all stakes to the `reserved` state.543 /// After the end of `PendingInterval` this sum becomes completely544 /// free for further use.545 #[pallet::call_index(8)]546 #[pallet::weight(<T as Config>::WeightInfo::unstake())]547 pub fn unstake_partial(staker: OriginFor<T>, amount: BalanceOf<T>) -> DispatchResult {548 let staker_id = ensure_signed(staker)?;549 let config = <PalletConfiguration<T>>::get();550551 // calculate block number where the sum would be free552 let block = <frame_system::Pallet<T>>::block_number() + config.pending_interval;553554 let mut pendings = <PendingUnstake<T>>::get(block);555556 // checks that we can do unreserve stakes in the block557 ensure!(!pendings.is_full(), Error::<T>::PendingForBlockOverflow);558559 Self::partial_unstake(&staker_id, amount, pendings, block)?;560561 let mut total_stakes = 0u64;562563 let total_staked: BalanceOf<T> = Staked::<T>::drain_prefix((&staker_id,))564 .map(|(_, (amount, _))| {565 total_stakes += 1;566 amount567 })568 .sum();569570 if total_staked.is_zero() {571 return Ok(()); // TO-DO572 }573574 // pendings575 // .try_push((staker_id.clone(), total_staked))576 // .map_err(|_| Error::<T>::PendingForBlockOverflow)?;577578 // <PendingUnstake<T>>::insert(block, pendings);579580 // TotalStaked::<T>::set(581 // TotalStaked::<T>::get()582 // .checked_sub(&total_staked)583 // .ok_or(ArithmeticError::Underflow)?,584 // );585586 // StakesPerAccount::<T>::remove(&staker_id);587588 Self::deposit_event(Event::Unstake(staker_id, total_staked));589590 Ok(())591 }592593 /// Sets the pallet to be the sponsor for the collection.594 ///595 /// # Permissions596 ///597 /// * Pallet admin598 ///599 /// # Arguments600 ///601 /// * `collection_id`: ID of the collection that will be sponsored by `pallet_id`602 #[pallet::call_index(3)]603 #[pallet::weight(<T as Config>::WeightInfo::sponsor_collection())]604 pub fn sponsor_collection(605 admin: OriginFor<T>,606 collection_id: CollectionId,607 ) -> DispatchResult {608 let admin_id = ensure_signed(admin)?;609 ensure!(610 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,611 Error::<T>::NoPermission612 );613614 T::CollectionHandler::set_sponsor(Self::account_id(), collection_id)615 }616617 /// Removes the pallet as the sponsor for the collection.618 /// Returns [`NoPermission`][`Error::NoPermission`]619 /// if the pallet wasn't the sponsor.620 ///621 /// # Permissions622 ///623 /// * Pallet admin624 ///625 /// # Arguments626 ///627 /// * `collection_id`: ID of the collection that is sponsored by `pallet_id`628 #[pallet::call_index(4)]629 #[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_collection())]630 pub fn stop_sponsoring_collection(631 admin: OriginFor<T>,632 collection_id: CollectionId,633 ) -> DispatchResult {634 let admin_id = ensure_signed(admin)?;635636 ensure!(637 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,638 Error::<T>::NoPermission639 );640641 ensure!(642 T::CollectionHandler::sponsor(collection_id)?.ok_or(<Error<T>>::SponsorNotSet)?643 == Self::account_id(),644 <Error<T>>::NoPermission645 );646 T::CollectionHandler::remove_collection_sponsor(collection_id)647 }648649 /// Sets the pallet to be the sponsor for the contract.650 ///651 /// # Permissions652 ///653 /// * Pallet admin654 ///655 /// # Arguments656 ///657 /// * `contract_id`: the contract address that will be sponsored by `pallet_id`658 #[pallet::call_index(5)]659 #[pallet::weight(<T as Config>::WeightInfo::sponsor_contract())]660 pub fn sponsor_contract(admin: OriginFor<T>, contract_id: H160) -> DispatchResult {661 let admin_id = ensure_signed(admin)?;662663 ensure!(664 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,665 Error::<T>::NoPermission666 );667668 T::ContractHandler::set_sponsor(669 T::CrossAccountId::from_sub(Self::account_id()),670 contract_id,671 )672 }673674 /// Removes the pallet as the sponsor for the contract.675 /// Returns [`NoPermission`][`Error::NoPermission`]676 /// if the pallet wasn't the sponsor.677 ///678 /// # Permissions679 ///680 /// * Pallet admin681 ///682 /// # Arguments683 ///684 /// * `contract_id`: the contract address that is sponsored by `pallet_id`685 #[pallet::call_index(6)]686 #[pallet::weight(<T as Config>::WeightInfo::stop_sponsoring_contract())]687 pub fn stop_sponsoring_contract(admin: OriginFor<T>, contract_id: H160) -> 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 );694695 ensure!(696 T::ContractHandler::sponsor(contract_id)?697 .ok_or(<Error<T>>::SponsorNotSet)?698 .as_sub() == &Self::account_id(),699 <Error<T>>::NoPermission700 );701 T::ContractHandler::remove_contract_sponsor(contract_id)702 }703704 /// Recalculates interest for the specified number of stakers.705 /// If all stakers are not recalculated, the next call of the extrinsic706 /// will continue the recalculation, from those stakers for whom this707 /// was not perform in last call.708 ///709 /// # Permissions710 ///711 /// * Pallet admin712 ///713 /// # Arguments714 ///715 /// * `stakers_number`: the number of stakers for which recalculation will be performed716 #[pallet::call_index(7)]717 #[pallet::weight(<T as Config>::WeightInfo::payout_stakers(stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS) as u32))]718 pub fn payout_stakers(admin: OriginFor<T>, stakers_number: Option<u8>) -> DispatchResult {719 let admin_id = ensure_signed(admin)?;720721 ensure!(722 admin_id == Admin::<T>::get().ok_or(Error::<T>::AdminNotSet)?,723 Error::<T>::NoPermission724 );725 let config = <PalletConfiguration<T>>::get();726727 let mut stakers_number = stakers_number.unwrap_or(DEFAULT_NUMBER_PAYOUTS);728729 ensure!(730 stakers_number <= config.max_stakers_per_calculation && stakers_number != 0,731 Error::<T>::NoPermission732 );733734 // calculate the number of the current recalculation block,735 // this is necessary in order to understand which stakers we should calculate interest736 let current_recalc_block = Self::get_current_recalc_block(737 T::RelayBlockNumberProvider::current_block_number(),738 &config,739 );740741 // calculate the number of the next recalculation block,742 // this value is set for the stakers to whom the recalculation will be performed743 let next_recalc_block = current_recalc_block + config.recalculation_interval;744745 let mut storage_iterator = Self::get_next_calculated_key()746 .map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));747748 PreviousCalculatedRecord::<T>::set(None);749750 {751 // Address handled in the last payout loop iteration (below)752 let last_id = RefCell::new(None);753 // Block number (as a part of the key) for which calculation was performed in the last payout loop iteration754 let mut last_staked_calculated_block = Default::default();755 // Reward balance for the address in the iteration756 let income_acc = RefCell::new(BalanceOf::<T>::default());757 // Staked balance for the address in the iteration (before stake is recalculated)758 let amount_acc = RefCell::new(BalanceOf::<T>::default());759760 // This closure is used to finalize handling single staker address in each of the two conditions: (1) when we break out of the payout761 // loop because we reached the number of stakes for rewarding, (2) When all stakes by the single address are handled and the payout762 // loop switches to handling the next staker address:763 // 1. Transfer full reward amount to the payee764 // 2. Lock the reward in staking lock765 // 3. Update TotalStaked amount766 // 4. Issue StakingRecalculation event767 let flush_stake = || -> DispatchResult {768 if let Some(last_id) = &*last_id.borrow() {769 if !income_acc.borrow().is_zero() {770 <<T as Config>::Currency as Currency<T::AccountId>>::transfer(771 &T::TreasuryAccountId::get(),772 last_id,773 *income_acc.borrow(),774 ExistenceRequirement::KeepAlive,775 )?;776777 Self::add_lock_balance(last_id, *income_acc.borrow())?;778 <TotalStaked<T>>::try_mutate(|staked| -> DispatchResult {779 *staked = staked780 .checked_add(&*income_acc.borrow())781 .ok_or(ArithmeticError::Overflow)?;782 Ok(())783 })?;784785 Self::deposit_event(Event::StakingRecalculation(786 last_id.clone(),787 *amount_acc.borrow(),788 *income_acc.borrow(),789 ));790 }791792 *income_acc.borrow_mut() = BalanceOf::<T>::default();793 *amount_acc.borrow_mut() = BalanceOf::<T>::default();794 }795 Ok(())796 };797798 // Reward payment loop. Should loop for no more than config.max_stakers_per_calculation799 // iterations in one extrinsic call800 //801 // stakers_number - keeps the remaining number of iterations (staker addresses to handle)802 // next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out803 // income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)804 while let Some((805 (current_id, staked_block),806 (amount, next_recalc_block_for_stake),807 )) = storage_iterator.next()808 {809 // last_id is not equal current_id when we switch to handling a new staker address810 // or just start handling the very first address. In the latter case last_id will be None and811 // flush_stake will do nothing812 if last_id.borrow().as_ref() != Some(¤t_id) {813 if stakers_number > 0 {814 flush_stake()?;815 *last_id.borrow_mut() = Some(current_id.clone());816 stakers_number -= 1;817 }818 // Break out if we reached the address limit819 else {820 if let Some(staker) = &*last_id.borrow() {821 // Save the last calculated record to pick up in the next extrinsic call822 PreviousCalculatedRecord::<T>::set(Some((823 staker.clone(),824 last_staked_calculated_block,825 )));826 }827 break;828 };829 };830831 // Increase accumulated reward for current address and update current staking record, i.e. (address, staked_block) -> amount832 if current_recalc_block >= next_recalc_block_for_stake {833 *amount_acc.borrow_mut() += amount;834 Self::recalculate_and_insert_stake(835 ¤t_id,836 staked_block,837 next_recalc_block,838 amount,839 ((current_recalc_block - next_recalc_block_for_stake)840 / config.recalculation_interval)841 .into() + 1,842 &mut *income_acc.borrow_mut(),843 );844 }845 last_staked_calculated_block = staked_block;846 }847 flush_stake()?;848 }849850 Ok(())851 }852 }853}854855impl<T: Config> Pallet<T> {856 /// The account address of the app promotion pot.857 ///858 /// This actually does computation. If you need to keep using it, then make sure you cache the859 /// value and only call this once.860 pub fn account_id() -> T::AccountId {861 T::PalletId::get().into_account_truncating()862 }863864 fn partial_unstake(865 staker_id: &T::AccountId,866 unstaked_balance: BalanceOf<T>,867 mut pendings: BoundedVec<868 (T::AccountId, BalanceOf<T>),869 sp_core::ConstU32<PENDING_LIMIT_PER_BLOCK>,870 >,871 pending_block: T::BlockNumber,872 ) -> DispatchResult {873 if unstaked_balance == Default::default() {874 return Ok(());875 }876877 let mut stakes = Staked::<T>::iter_prefix((staker_id,)).collect::<Vec<_>>();878879 let total_staked = stakes880 .iter()881 .fold(<BalanceOf<T>>::default(), |acc, (_, (balance, _))| {882 acc + *balance883 });884885 ensure!(total_staked >= unstaked_balance, ArithmeticError::Underflow);886887 <TotalStaked<T>>::set(888 <TotalStaked<T>>::get()889 .checked_sub(&unstaked_balance)890 .ok_or(ArithmeticError::Underflow)?,891 );892893 stakes.sort_by_key(|(block, _)| *block);894895 let mut acc_amount = unstaked_balance;896 let mut will_deleted_stakes_count = 0u8;897898 let changed_stakes = stakes899 .into_iter()900 .map_while(|(block, (balance_per_block, recalc_block))| {901 if acc_amount == <BalanceOf<T>>::default() {902 return None;903 }904 if acc_amount <= balance_per_block {905 let res = (block, (balance_per_block - acc_amount, recalc_block));906 acc_amount = <BalanceOf<T>>::default();907 return Some(res);908 } else {909 acc_amount -= balance_per_block;910 will_deleted_stakes_count += 1;911 return Some((block, (<BalanceOf<T>>::default(), recalc_block)));912 }913 })914 .collect::<Vec<_>>();915916 pendings917 .try_push((staker_id.clone(), unstaked_balance))918 .map_err(|_| Error::<T>::PendingForBlockOverflow)?;919920 StakesPerAccount::<T>::try_mutate(staker_id, |stakes| -> DispatchResult {921 *stakes = stakes922 .checked_div(will_deleted_stakes_count)923 .ok_or(ArithmeticError::Underflow)?;924 Ok(())925 })?;926927 changed_stakes928 .iter()929 .for_each(|(staked_block, (current_stake_state, _))| {930 if current_stake_state == &Default::default() {931 <Staked<T>>::remove((staker_id, staked_block));932 } else {933 <Staked<T>>::mutate((staker_id, staked_block), |(old_stake_state, _)| {934 *old_stake_state = *current_stake_state935 });936 }937 });938939 <PendingUnstake<T>>::insert(pending_block, pendings);940941 Ok(())942 }943944 /// Adds the balance to locked by the pallet.945 ///946 /// - `staker`: staker account.947 /// - `amount`: amount of added locked funds.948 fn add_lock_balance(staker: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {949 Self::get_locked_balance(staker)950 .map_or(<BalanceOf<T>>::default(), |l| l.amount)951 .checked_add(&amount)952 .map(|new_lock| Self::set_lock_unchecked(staker, new_lock))953 .ok_or(ArithmeticError::Overflow.into())954 }955956 /// Sets the new state of a balance locked by the pallet.957 ///958 /// - `staker`: staker account.959 /// - `amount`: amount of locked funds.960 fn set_lock_unchecked(staker: &T::AccountId, amount: BalanceOf<T>) {961 if amount.is_zero() {962 <<T as Config>::Currency as LockableCurrency<T::AccountId>>::remove_lock(963 LOCK_IDENTIFIER,964 &staker,965 );966 } else {967 <<T as Config>::Currency as LockableCurrency<T::AccountId>>::set_lock(968 LOCK_IDENTIFIER,969 staker,970 amount,971 WithdrawReasons::all(),972 )973 }974 }975976 /// Returns the balance locked by the pallet for the staker.977 ///978 /// - `staker`: staker account.979 pub fn get_locked_balance(980 staker: impl EncodeLike<T::AccountId>,981 ) -> Option<BalanceLock<BalanceOf<T>>> {982 <<T as Config>::Currency as ExtendedLockableCurrency<T::AccountId>>::locks(staker)983 .into_iter()984 .find(|l| l.id == LOCK_IDENTIFIER)985 }986987 /// Returns the total staked balance for the staker.988 ///989 /// - `staker`: staker account.990 pub fn total_staked_by_id(staker: impl EncodeLike<T::AccountId>) -> Option<BalanceOf<T>> {991 let staked = Staked::<T>::iter_prefix((staker,))992 .into_iter()993 .fold(<BalanceOf<T>>::default(), |acc, (_, (amount, _))| {994 acc + amount995 });996 if staked != <BalanceOf<T>>::default() {997 Some(staked)998 } else {999 None1000 }1001 }10021003 /// Returns all relay block numbers when stake was made,1004 /// the amount of the stake.1005 ///1006 /// - `staker`: staker account.1007 pub fn total_staked_by_id_per_block(1008 staker: impl EncodeLike<T::AccountId>,1009 ) -> Option<Vec<(T::BlockNumber, BalanceOf<T>)>> {1010 let mut staked = Staked::<T>::iter_prefix((staker,))1011 .into_iter()1012 .map(|(block, (amount, _))| (block, amount))1013 .collect::<Vec<_>>();1014 staked.sort_by_key(|(block, _)| *block);1015 if !staked.is_empty() {1016 Some(staked)1017 } else {1018 None1019 }1020 }10211022 /// Returns the total staked balance for the staker.1023 /// If `staker` is `None`, returns the total amount staked.1024 /// - `staker`: staker account.1025 pub fn cross_id_total_staked(staker: Option<T::CrossAccountId>) -> Option<BalanceOf<T>> {1026 staker.map_or(Some(<TotalStaked<T>>::get()), |s| {1027 Self::total_staked_by_id(s.as_sub())1028 })1029 }10301031 // pub fn cross_id_locked_balance(staker: T::CrossAccountId) -> BalanceOf<T> {1032 // Self::get_locked_balance(staker.as_sub())1033 // .map(|l| l.amount)1034 // .unwrap_or_default()1035 // }10361037 /// Returns all relay block numbers when stake was made,1038 /// the amount of the stake.1039 ///1040 /// - `staker`: staker account.1041 pub fn cross_id_total_staked_per_block(1042 staker: T::CrossAccountId,1043 ) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1044 Self::total_staked_by_id_per_block(staker.as_sub()).unwrap_or_default()1045 }10461047 fn recalculate_and_insert_stake(1048 staker: &T::AccountId,1049 staked_block: T::BlockNumber,1050 next_recalc_block: T::BlockNumber,1051 base: BalanceOf<T>,1052 iters: u32,1053 income_acc: &mut BalanceOf<T>,1054 ) {1055 let income = Self::calculate_income(base, iters);10561057 base.checked_add(&income).map(|res| {1058 <Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));1059 *income_acc += income;1060 });1061 }10621063 fn calculate_income<I>(base: I, iters: u32) -> I1064 where1065 I: EncodeLike<BalanceOf<T>> + Balance,1066 {1067 let config = <PalletConfiguration<T>>::get();1068 let mut income = base;10691070 (0..iters).for_each(|_| income += config.interval_income * income);10711072 income - base1073 }10741075 /// Get relay block number rounded down to multiples of config.recalculation_interval.1076 /// We need it to reward stakers in integer parts of recalculation_interval1077 fn get_current_recalc_block(1078 current_relay_block: T::BlockNumber,1079 config: &PalletConfiguration<T>,1080 ) -> T::BlockNumber {1081 (current_relay_block / config.recalculation_interval) * config.recalculation_interval1082 }10831084 fn get_next_calculated_key() -> Option<Vec<u8>> {1085 Self::get_next_calculated_record().map(|key| Staked::<T>::hashed_key_for(key))1086 }1087}10881089impl<T: Config> Pallet<T>1090where1091 <<T as Config>::Currency as Currency<T::AccountId>>::Balance: Sum,1092{1093 /// Returns the amount reserved by the pending.1094 /// If `staker` is `None`, returns the total pending.1095 ///1096 /// -`staker`: staker account.1097 ///1098 /// Since user funds are not transferred anywhere by staking, overflow protection is provided1099 /// at the level of the associated type `Balance` of `Currency` trait. In order to overflow,1100 /// the staker must have more funds on his account than the maximum set for `Balance` type.1101 pub fn cross_id_pending_unstake(staker: Option<T::CrossAccountId>) -> BalanceOf<T> {1102 staker.map_or(1103 PendingUnstake::<T>::iter_values()1104 .flat_map(|pendings| pendings.into_iter().map(|(_, amount)| amount))1105 .sum(),1106 |s| {1107 PendingUnstake::<T>::iter_values()1108 .flatten()1109 .filter_map(|(id, amount)| {1110 if id == *s.as_sub() {1111 Some(amount)1112 } else {1113 None1114 }1115 })1116 .sum()1117 },1118 )1119 }11201121 /// Returns all parachain block numbers when unreserve is expected,1122 /// the amount of the unreserved funds.1123 ///1124 /// - `staker`: staker account.1125 pub fn cross_id_pending_unstake_per_block(1126 staker: T::CrossAccountId,1127 ) -> Vec<(T::BlockNumber, BalanceOf<T>)> {1128 let mut unsorted_res = vec![];1129 PendingUnstake::<T>::iter().for_each(|(block, pendings)| {1130 pendings.into_iter().for_each(|(id, amount)| {1131 if id == *staker.as_sub() {1132 unsorted_res.push((block, amount));1133 };1134 })1135 });11361137 unsorted_res.sort_by_key(|(block, _)| *block);1138 unsorted_res1139 }1140}