added more robust tests to make sure interest accrues, added oracleless deposit_obligation_collateral, updated instruction.rs for writable account

Author: nope-finance

token-lending/program/src/instruction.rs

@@ -161,15 +161,15 @@ pub enum LendingInstruction {
     RefreshObligation,
 
     // 8
-    /// Deposit collateral to an obligation. Requires a refreshed reserve.
+    /// Deposit collateral to an obligation.
     ///
     /// Accounts expected by this instruction:
     ///
     ///   0. `[writable]` Source collateral token account.
     ///                     Minted by deposit reserve collateral mint.
     ///                     $authority can transfer $collateral_amount.
     ///   1. `[writable]` Destination deposit reserve collateral supply SPL Token account.
-    ///   2. `[]` Deposit reserve account - refreshed.
+    ///   2. `[writable]` Deposit reserve account.
     ///   3. `[writable]` Obligation account.
     ///   4. `[]` Lending market account.
     ///   5. `[signer]` Obligation owner.
@@ -948,7 +948,7 @@ pub fn deposit_obligation_collateral(
         accounts: vec![
             AccountMeta::new(source_collateral_pubkey, false),
             AccountMeta::new(destination_collateral_pubkey, false),
-            AccountMeta::new_readonly(deposit_reserve_pubkey, false),
+            AccountMeta::new(deposit_reserve_pubkey, false),
             AccountMeta::new(obligation_pubkey, false),
             AccountMeta::new_readonly(lending_market_pubkey, false),
             AccountMeta::new_readonly(obligation_owner_pubkey, true),

token-lending/program/src/processor.rs

@@ -473,9 +473,6 @@ fn process_deposit_reserve_liquidity(
         clock,
         token_program_id,
     )?;
-    let mut reserve = Reserve::unpack(&reserve_info.data.borrow())?;
-    reserve.last_update.mark_stale();
-    Reserve::pack(reserve, &mut reserve_info.data.borrow_mut())?;
 
     Ok(())
 }
@@ -907,6 +904,7 @@ fn process_deposit_obligation_collateral(
     let user_transfer_authority_info = next_account_info(account_info_iter)?;
     let clock = &Clock::from_account_info(next_account_info(account_info_iter)?)?;
     let token_program_id = next_account_info(account_info_iter)?;
+    _refresh_reserve_interest(program_id, deposit_reserve_info, clock)?;
     _deposit_obligation_collateral(
         program_id,
         collateral_amount,
@@ -919,7 +917,11 @@ fn process_deposit_obligation_collateral(
         user_transfer_authority_info,
         clock,
         token_program_id,
-    )
+    )?;
+    let mut reserve = Reserve::unpack(&deposit_reserve_info.data.borrow())?;
+    reserve.last_update.mark_stale();
+    Reserve::pack(reserve, &mut deposit_reserve_info.data.borrow_mut())?;
+    Ok(())
 }
 
 #[allow(clippy::too_many_arguments)]

token-lending/program/tests/deposit_obligation_collateral.rs

@@ -28,6 +28,7 @@ async fn test_success() {
 
     const SOL_DEPOSIT_AMOUNT_LAMPORTS: u64 = 10 * LAMPORTS_TO_SOL * INITIAL_COLLATERAL_RATIO;
     const SOL_RESERVE_COLLATERAL_LAMPORTS: u64 = 2 * SOL_DEPOSIT_AMOUNT_LAMPORTS;
+    const SOL_BORROWED_AMOUNT_LAMPORTS: u64 = SOL_DEPOSIT_AMOUNT_LAMPORTS;
 
     let user_accounts_owner = Keypair::new();
     let user_transfer_authority = Keypair::new();
@@ -45,6 +46,7 @@ async fn test_success() {
             liquidity_amount: SOL_RESERVE_COLLATERAL_LAMPORTS,
             liquidity_mint_decimals: 9,
             liquidity_mint_pubkey: spl_token::native_mint::id(),
+            borrow_amount: SOL_BORROWED_AMOUNT_LAMPORTS,
             config: test_reserve_config(),
             mark_fresh: true,
             ..AddReserveArgs::default()
@@ -57,15 +59,25 @@ async fn test_success() {
         &user_accounts_owner,
         AddObligationArgs::default(),
     );
+    
+    let mut test_context = test.start_with_context().await;
+    test_context.warp_to_slot(300).unwrap(); // clock.slot = 300
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let ProgramTestContext {
+        mut banks_client,
+        payer,
+        last_blockhash: recent_blockhash,
+        ..
+    } = test_context;
 
     test_obligation.validate_state(&mut banks_client).await;
 
     let initial_collateral_supply_balance =
         get_token_balance(&mut banks_client, sol_test_reserve.collateral_supply_pubkey).await;
     let initial_user_collateral_balance =
         get_token_balance(&mut banks_client, sol_test_reserve.user_collateral_pubkey).await;
+    let pre_sol_reserve = sol_test_reserve.get_state(&mut banks_client).await;
+    let old_borrow_rate = pre_sol_reserve.liquidity.cumulative_borrow_rate_wads;
 
     let mut transaction = Transaction::new_with_payer(
         &[
@@ -99,6 +111,10 @@ async fn test_success() {
     );
     assert!(banks_client.process_transaction(transaction).await.is_ok());
 
+
+    let sol_reserve = sol_test_reserve.get_state(&mut banks_client).await;
+    assert_eq!(sol_reserve.last_update.stale, true);
+
     // check that collateral tokens were transferred
     let collateral_supply_balance =
         get_token_balance(&mut banks_client, sol_test_reserve.collateral_supply_pubkey).await;
@@ -112,4 +128,6 @@ async fn test_success() {
         user_collateral_balance,
         initial_user_collateral_balance - SOL_DEPOSIT_AMOUNT_LAMPORTS
     );
+
+    assert!(sol_reserve.liquidity.cumulative_borrow_rate_wads > old_borrow_rate);
 }

token-lending/program/tests/deposit_reserve_liquidity.rs

@@ -16,7 +16,7 @@ async fn test_success() {
     );
 
     // limit to track compute unit increase
-    test.set_bpf_compute_max_units(35_000);
+    test.set_bpf_compute_max_units(45_000);
 
     let user_accounts_owner = Keypair::new();
     let lending_market = add_lending_market(&mut test);
@@ -33,13 +33,25 @@ async fn test_success() {
             liquidity_amount: 10_000 * FRACTIONAL_TO_USDC,
             liquidity_mint_decimals: usdc_mint.decimals,
             liquidity_mint_pubkey: usdc_mint.pubkey,
+            borrow_amount: 5_000 * FRACTIONAL_TO_USDC,
             config: test_reserve_config(),
             mark_fresh: true,
             ..AddReserveArgs::default()
         },
     );
 
-    let (mut banks_client, payer, _recent_blockhash) = test.start().await;
+    let mut test_context = test.start_with_context().await;
+    test_context.warp_to_slot(300).unwrap(); // clock.slot = 300
+
+    let ProgramTestContext {
+        mut banks_client,
+        payer,
+        ..
+    } = test_context;
+    
+    let initial_ctoken_amount = get_token_balance(&mut banks_client, usdc_test_reserve.user_collateral_pubkey).await;
+    let pre_usdc_reserve = usdc_test_reserve.get_state(&mut banks_client).await;
+    let old_borrow_rate = pre_usdc_reserve.liquidity.cumulative_borrow_rate_wads;
 
     lending_market
         .deposit(
@@ -50,4 +62,19 @@ async fn test_success() {
             100 * FRACTIONAL_TO_USDC,
         )
         .await;
+    
+    
+    let usdc_reserve = usdc_test_reserve.get_state(&mut banks_client).await;
+    assert_eq!(usdc_reserve.last_update.stale, true);
+    
+    let user_remaining_liquidity_amount = get_token_balance(&mut banks_client, usdc_test_reserve.user_liquidity_pubkey).await;
+    assert_eq!(user_remaining_liquidity_amount, 0);
+
+    let final_ctoken_amount = get_token_balance(&mut banks_client, usdc_test_reserve.user_collateral_pubkey).await;
+    assert!(final_ctoken_amount - initial_ctoken_amount < 100 * FRACTIONAL_TO_USDC);
+    
+    assert!(
+        usdc_reserve.liquidity.cumulative_borrow_rate_wads >
+        old_borrow_rate
+    );
 }

token-lending/program/tests/deposit_reserve_liquidity_and_obligation_collateral.rs

@@ -50,10 +50,6 @@ async fn test_success() {
 
     test_obligation.validate_state(&mut banks_client).await;
 
-    // let initial_collateral_supply_balance =
-    //     get_token_balance(&mut banks_client, usdc_test_reserve.collateral_supply_pubkey).await;
-    // let initial_user_collateral_balance =
-    //     get_token_balance(&mut banks_client, usdc_test_reserve.user_collateral_pubkey).await;
 
     lending_market
         .deposit_obligation_and_collateral(

token-lending/program/tests/obligation_end_to_end.rs

@@ -123,13 +123,6 @@ async fn test_success() {
                 user_accounts_owner_pubkey,
             ),
             // 2
-            refresh_reserve(
-                spl_token_lending::id(),
-                sol_test_reserve.pubkey,
-                sol_oracle.pyth_price_pubkey,
-                sol_oracle.switchboard_feed_pubkey,
-            ),
-            // 3
             approve(
                 &spl_token::id(),
                 &sol_test_reserve.user_collateral_pubkey,
@@ -139,7 +132,7 @@ async fn test_success() {
                 SOL_DEPOSIT_AMOUNT_LAMPORTS,
             )
             .unwrap(),
-            // 4
+            // 3
             deposit_obligation_collateral(
                 spl_token_lending::id(),
                 SOL_DEPOSIT_AMOUNT_LAMPORTS,
@@ -151,19 +144,26 @@ async fn test_success() {
                 user_accounts_owner_pubkey,
                 user_transfer_authority_pubkey,
             ),
-            // 5
-            refresh_obligation(
-                spl_token_lending::id(),
-                obligation_pubkey,
-                vec![sol_test_reserve.pubkey],
-            ),
-            // 6
+            // 4
             refresh_reserve(
                 spl_token_lending::id(),
                 usdc_test_reserve.pubkey,
                 usdc_oracle.pyth_price_pubkey,
                 usdc_oracle.switchboard_feed_pubkey,
             ),
+            // 5
+            refresh_reserve(
+                spl_token_lending::id(),
+                sol_test_reserve.pubkey,
+                sol_oracle.pyth_price_pubkey,
+                sol_oracle.switchboard_feed_pubkey,
+            ),
+            // 6
+            refresh_obligation(
+                spl_token_lending::id(),
+                obligation_pubkey,
+                vec![sol_test_reserve.pubkey],
+            ),
             // 7
             borrow_obligation_liquidity(
                 spl_token_lending::id(),
@@ -178,19 +178,6 @@ async fn test_success() {
                 Some(usdc_test_reserve.liquidity_host_pubkey),
             ),
             // 8
-            refresh_reserve(
-                spl_token_lending::id(),
-                usdc_test_reserve.pubkey,
-                usdc_oracle.pyth_price_pubkey,
-                usdc_oracle.switchboard_feed_pubkey,
-            ),
-            // 9
-            refresh_obligation(
-                spl_token_lending::id(),
-                obligation_pubkey,
-                vec![sol_test_reserve.pubkey, usdc_test_reserve.pubkey],
-            ),
-            // 10
             approve(
                 &spl_token::id(),
                 &usdc_test_reserve.user_liquidity_pubkey,
@@ -200,7 +187,7 @@ async fn test_success() {
                 USDC_REPAY_AMOUNT_FRACTIONAL,
             )
             .unwrap(),
-            // 11
+            // 9
             repay_obligation_liquidity(
                 spl_token_lending::id(),
                 USDC_REPAY_AMOUNT_FRACTIONAL,
@@ -211,13 +198,20 @@ async fn test_success() {
                 lending_market.pubkey,
                 user_transfer_authority_pubkey,
             ),
-            // 12
+            // 10
+            refresh_reserve(
+                spl_token_lending::id(),
+                usdc_test_reserve.pubkey,
+                usdc_oracle.pyth_price_pubkey,
+                usdc_oracle.switchboard_feed_pubkey,
+            ),
+            // 11
             refresh_obligation(
                 spl_token_lending::id(),
                 obligation_pubkey,
                 vec![sol_test_reserve.pubkey],
             ),
-            // 13
+            // 12
             withdraw_obligation_collateral(
                 spl_token_lending::id(),
                 SOL_DEPOSIT_AMOUNT_LAMPORTS,

token-lending/program/tests/redeem_reserve_collateral.rs

@@ -24,13 +24,14 @@ async fn test_success() {
     );
 
     // limit to track compute unit increase
-    test.set_bpf_compute_max_units(35_000);
+    test.set_bpf_compute_max_units(45_000);
 
     let user_accounts_owner = Keypair::new();
     let lending_market = add_lending_market(&mut test);
 
     const USDC_RESERVE_LIQUIDITY_FRACTIONAL: u64 = 10 * FRACTIONAL_TO_USDC;
     const COLLATERAL_AMOUNT: u64 = USDC_RESERVE_LIQUIDITY_FRACTIONAL * INITIAL_COLLATERAL_RATIO;
+    const BORROWED_AMOUNT: u64 = FRACTIONAL_TO_USDC;
 
     let usdc_mint = add_usdc_mint(&mut test);
     let usdc_oracle = add_usdc_oracle(&mut test);
@@ -41,16 +42,28 @@ async fn test_success() {
         &user_accounts_owner,
         AddReserveArgs {
             collateral_amount: COLLATERAL_AMOUNT,
-            liquidity_amount: USDC_RESERVE_LIQUIDITY_FRACTIONAL,
+            liquidity_amount: 2 * USDC_RESERVE_LIQUIDITY_FRACTIONAL,
             liquidity_mint_decimals: usdc_mint.decimals,
             liquidity_mint_pubkey: usdc_mint.pubkey,
+            borrow_amount: BORROWED_AMOUNT,
             config: test_reserve_config(),
             mark_fresh: true,
             ..AddReserveArgs::default()
         },
     );
 
-    let (mut banks_client, payer, recent_blockhash) = test.start().await;
+    let mut test_context = test.start_with_context().await;
+    test_context.warp_to_slot(300).unwrap(); // clock.slot = 300
+
+    let ProgramTestContext {
+        mut banks_client,
+        payer,
+        last_blockhash: recent_blockhash,
+        ..
+    } = test_context;
+
+    let pre_usdc_reserve = usdc_test_reserve.get_state(&mut banks_client).await;
+    let old_borrow_rate = pre_usdc_reserve.liquidity.cumulative_borrow_rate_wads;
 
     let user_transfer_authority = Keypair::new();
     let mut transaction = Transaction::new_with_payer(
@@ -84,4 +97,13 @@ async fn test_success() {
         recent_blockhash,
     );
     assert!(banks_client.process_transaction(transaction).await.is_ok());
+
+    let usdc_reserve = usdc_test_reserve.get_state(&mut banks_client).await;
+    assert_eq!(usdc_reserve.last_update.stale, true);
+    
+    assert!(
+        usdc_reserve.liquidity.cumulative_borrow_rate_wads >
+        old_borrow_rate
+    );
+
 }