rewards split (#771)

* make renders work with new line

* sometimes shares should be split or transfered to new account

* added split test with prove of withdrawals

* removding mult by ration and use u256 directly

* fixed split

* ensure of option

Author: dzmitry-lahoda

rewards/README.md

@@ -1,12 +1,10 @@
 # Rewards module
 
-### Overview
-
 This module exposes capabilities for staking rewards.
 
-### Single asset algorithm
+## Single asset algorithm
 
-If consider a single pool with a single reward asset, generally it will behave as next:
+Consider a single pool with a single reward asset, generally, it will behave as next:
 
 ```python
 from collections import defaultdict
@@ -54,9 +52,13 @@ Let $R_n$ be the amount of the current reward asset.
 
 Let $s_i$ be the stake of any specific user our of $m$ total users.
 
-User current reward share equals $$r_i = R_n * ({s_i} / {\sum_{i=1}^m s_i}) $$
+User current reward share equals
+
+$$ r_i = R_n * ({s_i} / {\sum_{i=1}^m s_i}) $$
+
+User $m + 1$ brings his share, so
 
-User $m + 1$ brings his share, so $$r_i' = R_n * ({s_i} / {\sum_{i=1}^{m+1} s_i}) $$
+$$r_i' = R_n * ({s_i} / {\sum_{i=1}^{m+1} s_i}) $$
 
 $r_i > r_i'$, so the original share was diluted and a new user can claim the share of existing users.
 

rewards/src/lib.rs

@@ -43,6 +43,7 @@ pub use module::*;
 
 #[frame_support::pallet]
 pub mod module {
+
 	use super::*;
 
 	#[pallet::config]
@@ -76,10 +77,14 @@ pub mod module {
 		type Handler: RewardHandler<Self::AccountId, Self::CurrencyId, Balance = Self::Balance, PoolId = Self::PoolId>;
 	}
 
+	type WithdrawnRewards<T> = BTreeMap<<T as Config>::CurrencyId, <T as Config>::Balance>;
+
 	#[pallet::error]
 	pub enum Error<T> {
 		/// Pool does not exist
 		PoolDoesNotExist,
+		ShareDoesNotExist,
+		CanSplitOnlyLessThanShare,
 	}
 
 	/// Record reward pool info.
@@ -102,7 +107,7 @@ pub mod module {
 		T::PoolId,
 		Twox64Concat,
 		T::AccountId,
-		(T::Share, BTreeMap<T::CurrencyId, T::Balance>),
+		(T::Share, WithdrawnRewards<T>),
 		ValueQuery,
 	>;
 
@@ -316,6 +321,51 @@ impl<T: Config> Pallet<T> {
 		});
 	}
 
+	/// Splits share into two parts.
+	///
+	/// `move_share` - amount of share to remove and put into `other` share
+	/// `other` - new account who will own new share
+	///
+	/// Similar too claim and add 2 shares later, but does not requires pool
+	/// inflation and is more efficient.
+	pub fn transfer_share_and_rewards(
+		who: &T::AccountId,
+		pool: &T::PoolId,
+		move_share: T::Share,
+		other: &T::AccountId,
+	) -> DispatchResult {
+		SharesAndWithdrawnRewards::<T>::mutate(pool, other, |increased_share| {
+			let (increased_share, increased_rewards) = increased_share;
+			SharesAndWithdrawnRewards::<T>::mutate_exists(pool, who, |share| {
+				let (share, rewards) = share.as_mut().ok_or(Error::<T>::ShareDoesNotExist)?;
+				ensure!(move_share < *share, Error::<T>::CanSplitOnlyLessThanShare);
+				for (reward_currency, balance) in rewards {
+					// u128 * u128 is always less than u256
+					// move_share / share always less then 1 and share > 0
+					// so final results is computable and is always less or equal than u128
+					let move_balance = U256::from(balance.to_owned().saturated_into::<u128>())
+						* U256::from(move_share.to_owned().saturated_into::<u128>())
+						/ U256::from(share.to_owned().saturated_into::<u128>());
+					let move_balance: Option<u128> = move_balance.try_into().ok();
+					if let Some(move_balance) = move_balance {
+						let move_balance: T::Balance = move_balance.unique_saturated_into();
+						*balance = balance.saturating_sub(move_balance);
+						increased_rewards
+							.entry(*reward_currency)
+							.and_modify(|increased_reward| {
+								*increased_reward = increased_reward.saturating_add(move_balance);
+							})
+							.or_insert(move_balance);
+					}
+				}
+				*share = share.saturating_sub(move_share);
+				*increased_share = increased_share.saturating_add(move_share);
+				Ok(())
+			})
+		})
+	}
+
+	#[allow(clippy::too_many_arguments)] // just we need to have all these to do the stuff
 	fn claim_one(
 		withdrawn_rewards: &mut BTreeMap<T::CurrencyId, T::Balance>,
 		reward_currency: T::CurrencyId,

rewards/src/tests.rs

@@ -530,3 +530,40 @@ fn claim_single_reward() {
 		);
 	});
 }
+
+#[test]
+fn transfer_share_and_rewards() {
+	ExtBuilder::default().build().execute_with(|| {
+		RewardsModule::add_share(&ALICE, &DOT_POOL, 100);
+		assert_ok!(RewardsModule::accumulate_reward(&DOT_POOL, NATIVE_COIN, 100));
+		RewardsModule::add_share(&BOB, &DOT_POOL, 100);
+		let pool_info = RewardsModule::pool_infos(DOT_POOL);
+		assert_ok!(RewardsModule::transfer_share_and_rewards(&ALICE, &DOT_POOL, 33, &BOB));
+		assert_ok!(RewardsModule::transfer_share_and_rewards(&ALICE, &DOT_POOL, 33, &CAROL));
+		let new_pool_info = RewardsModule::pool_infos(DOT_POOL);
+		assert_eq!(pool_info, new_pool_info, "reward transfer does not affect the pool");
+
+		assert_eq!(
+			RewardsModule::shares_and_withdrawn_rewards(DOT_POOL, ALICE),
+			(34, Default::default())
+		);
+		assert_eq!(
+			RewardsModule::shares_and_withdrawn_rewards(DOT_POOL, BOB),
+			(133, vec![(NATIVE_COIN, 100)].into_iter().collect())
+		);
+		assert_eq!(
+			RewardsModule::shares_and_withdrawn_rewards(DOT_POOL, CAROL),
+			(33, Default::default())
+		);
+		assert_ok!(RewardsModule::transfer_share_and_rewards(&BOB, &DOT_POOL, 10, &CAROL));
+		assert_eq!(
+			RewardsModule::shares_and_withdrawn_rewards(DOT_POOL, CAROL),
+			(43, vec![(NATIVE_COIN, 100 * 10 / 133)].into_iter().collect())
+		);
+
+		assert_noop!(
+			RewardsModule::transfer_share_and_rewards(&CAROL, &DOT_POOL, 1000, &ALICE),
+			Error::<Runtime>::CanSplitOnlyLessThanShare
+		);
+	});
+}