Adding Suilend test 'test_pool_reward_manager_basic'

Author: vanitymnm

Cargo.lock

@@ -65,7 +65,7 @@ struct ClaimUserReward<'a, 'info> {
 
 /// # Effects
 ///
-/// 1. Updates the user reward manager with the pool reward manager and accrues rewards
+/// 1. Finds the [UserRewardManager] for the reserve and obligation.
 /// 2. Withdraws all eligible rewards from [UserRewardManager].
 ///    Eligible rewards are those that match the vault and user has earned any.
 /// 3. Transfers the withdrawn rewards to the user's token account.
@@ -134,11 +134,6 @@ pub(crate) fn process(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramR
 
     let pool_reward_manager = accounts.reserve.pool_reward_manager_mut(position_kind);
 
-    // Syncs the pool reward manager with the user manager and accrues rewards.
-    // If we wanted to optimize CU usage then we could make a dedicated update
-    // function only for claiming rewards to avoid iterating twice over the rewards.
-    user_reward_manager.update(pool_reward_manager, clock)?;
-
     // 2.
 
     let total_reward_amount = user_reward_manager.claim_rewards(

token-lending/program/src/processor/liquidity_mining/claim_user_reward.rs

@@ -72,7 +72,7 @@ mod cu_budgets {
     pub(super) const DEPOSIT: u32 = 50_012;
     pub(super) const DONATE_TO_RESERVE: u32 = 50_013;
     pub(super) const UPDATE_RESERVE_CONFIG: u32 = 30_014;
-    pub(super) const DEPOSIT_RESERVE_LIQUIDITY_AND_OBLIGATION_COLLATERAL: u32 = 70_015;
+    pub(super) const DEPOSIT_RESERVE_LIQUIDITY_AND_OBLIGATION_COLLATERAL: u32 = 100_015;
     pub(super) const REDEEM: u32 = 58_016;
 }
 

token-lending/program/tests/helpers/solend_program_test.rs

@@ -23,6 +23,7 @@ uint = "=0.9.1"
 assert_matches = "1.5.0"
 base64 = "0.13"
 log = "0.4.14"
+pretty_assertions = "1.4.1"
 proptest = "1.6"
 rand = "0.8.5"
 serde = ">=1.0.140"

token-lending/sdk/Cargo.toml

@@ -203,7 +203,7 @@ impl PoolRewardManager {
 
         let start_time_secs = start_time_secs.max(clock.unix_timestamp as u64);
 
-        if start_time_secs <= end_time_secs {
+        if start_time_secs >= end_time_secs {
             msg!("Pool reward must end after it starts");
             return Err(LendingError::MathOverflow.into());
         }
@@ -420,24 +420,7 @@ impl UserRewardManagers {
             self.0.last_mut().unwrap()
         };
 
-        msg!(
-            "For reserve {} there are {} total shares. \
-            User's previous position was at {} and new is at {}",
-            reserve,
-            pool_reward_manager.total_shares,
-            user_reward_manager.share,
-            new_share
-        );
-
-        // This works even for migrations.
-        // User's old share is 0 although it shouldn't be bcs they have borrowed
-        // or deposited.
-        // We only now attribute the share to the user which is fine, it's as if
-        // they just now borrowed/deposited.
-        pool_reward_manager.total_shares =
-            pool_reward_manager.total_shares - user_reward_manager.share + new_share;
-
-        user_reward_manager.share = new_share;
+        user_reward_manager.set_share(pool_reward_manager, new_share);
 
         Ok(())
     }
@@ -455,17 +438,42 @@ impl UserRewardManager {
         }
     }
 
+    /// Sets new share value for this manager.
+    fn set_share(&mut self, pool_reward_manager: &mut PoolRewardManager, new_share: u64) {
+        msg!(
+            "For reserve {} there are {} total shares. \
+            User's previous position was at {} and new is at {}",
+            self.reserve,
+            pool_reward_manager.total_shares,
+            self.share,
+            new_share
+        );
+
+        // This works even for migrations.
+        // User's old share is 0 although it shouldn't be bcs they have borrowed
+        // or deposited.
+        // We only now attribute the share to the user which is fine, it's as if
+        // they just now borrowed/deposited.
+        pool_reward_manager.total_shares =
+            pool_reward_manager.total_shares - self.share + new_share;
+
+        self.share = new_share;
+    }
+
     /// Claims all rewards that the user has earned.
     /// Returns how many tokens should be transferred to the user.
     ///
     /// # Note
+    ///
     /// Errors if there is no pool reward with this vault.
     pub fn claim_rewards(
         &mut self,
         pool_reward_manager: &mut PoolRewardManager,
         vault: Pubkey,
         clock: &Clock,
     ) -> Result<u64, ProgramError> {
+        self.update(pool_reward_manager, clock)?;
+
         let (pool_reward_index, pool_reward) = pool_reward_manager
             .pool_rewards
             .iter()
@@ -1024,9 +1032,12 @@ mod tests {
     //! TODO: Calculate test coverage and add tests for missing branches.
 
     use super::*;
+    use pretty_assertions::assert_eq;
     use proptest::prelude::*;
     use rand::Rng;
 
+    const MILLISECONDS_IN_DAY: u64 = 86_400_000;
+
     fn pool_reward_manager_strategy() -> impl Strategy<Value = PoolRewardManager> {
         (0..1u32).prop_perturb(|_, mut rng| PoolRewardManager::new_rand(&mut rng))
     }
@@ -1109,9 +1120,110 @@ mod tests {
         assert!(required_realloc <= MAX_REALLOC);
     }
 
+    /// This tests replicates calculations from Suilend's
+    /// "test_pool_reward_manager_basic" test.
     #[test]
     fn it_tests_pool_reward_manager_basic() {
-        // TODO: rewrite Suilend "test_pool_reward_manager_basic" test
+        let usdc = Pubkey::new_unique(); // reserve pubkey
+        let slnd_vault = Pubkey::new_unique(); // where rewards are stored
+
+        let mut clock = Clock {
+            unix_timestamp: 0,
+            ..Default::default()
+        };
+
+        let mut pool_reward_manager = PoolRewardManager::default();
+        {
+            // setup pool reward manager with one reward
+
+            pool_reward_manager
+                .add_pool_reward(
+                    slnd_vault,
+                    0,
+                    20 * MILLISECONDS_IN_DAY,
+                    100 * 1_000_000,
+                    &clock,
+                )
+                .expect("It adds pool reward");
+            assert_eq!(
+                pool_reward_manager.pool_rewards[0],
+                PoolRewardSlot::Occupied(Box::new(PoolReward {
+                    id: PoolRewardId(1),
+                    vault: slnd_vault,
+                    start_time_secs: 0,
+                    duration_secs: 20 * MILLISECONDS_IN_DAY as u32,
+                    total_rewards: 100 * 1_000_000,
+                    cumulative_rewards_per_share: Decimal::zero(),
+                    num_user_reward_managers: 0,
+                }))
+            );
+        }
+
+        let mut user_reward_manager_1 = UserRewardManager::new(usdc, PositionKind::Deposit, &clock);
+        {
+            // setup user reward manager with 100/100 shares
+
+            user_reward_manager_1
+                .populate(&mut pool_reward_manager, &clock)
+                .expect("It populates user reward manager");
+            user_reward_manager_1.set_share(&mut pool_reward_manager, 100);
+        }
+
+        {
+            // 1/4 of the reward time passes
+            clock.unix_timestamp = 5 * MILLISECONDS_IN_DAY as i64;
+
+            let claimed_slnd = user_reward_manager_1
+                .claim_rewards(&mut pool_reward_manager, slnd_vault, &clock)
+                .expect("It claims rewards");
+            assert_eq!(claimed_slnd, 25 * 1_000_000);
+        }
+
+        let mut user_reward_manager_2 = UserRewardManager::new(usdc, PositionKind::Deposit, &clock);
+        {
+            // setup user reward manager with 400/500 shares
+
+            user_reward_manager_2
+                .populate(&mut pool_reward_manager, &clock)
+                .expect("It populates user reward manager");
+            user_reward_manager_2.set_share(&mut pool_reward_manager, 400);
+        }
+
+        {
+            // 1/2 of the reward time passes
+            clock.unix_timestamp = 10 * MILLISECONDS_IN_DAY as i64;
+
+            let claimed_slnd = user_reward_manager_1
+                .claim_rewards(&mut pool_reward_manager, slnd_vault, &clock)
+                .expect("It claims rewards");
+            assert_eq!(claimed_slnd, 5 * 1_000_000);
+
+            let claimed_slnd = user_reward_manager_2
+                .claim_rewards(&mut pool_reward_manager, slnd_vault, &clock)
+                .expect("It claims rewards");
+            assert_eq!(claimed_slnd, 20 * 1_000_000);
+        }
+
+        {
+            // set both user reward managers to 250/500 shares
+            user_reward_manager_1.set_share(&mut pool_reward_manager, 250);
+            user_reward_manager_2.set_share(&mut pool_reward_manager, 250);
+        }
+
+        {
+            // the reward is finished
+            clock.unix_timestamp = 20 * MILLISECONDS_IN_DAY as i64;
+
+            let claimed_slnd = user_reward_manager_1
+                .claim_rewards(&mut pool_reward_manager, slnd_vault, &clock)
+                .expect("It claims rewards");
+            assert_eq!(claimed_slnd, 25 * 1_000_000);
+
+            let claimed_slnd = user_reward_manager_2
+                .claim_rewards(&mut pool_reward_manager, slnd_vault, &clock)
+                .expect("It claims rewards");
+            assert_eq!(claimed_slnd, 25 * 1_000_000);
+        }
     }
 
     #[test]