Nour/settle pnl fix (#1817)

* settle perp to lp pool bug fixes

* update bankrun test to not use admin fee pool deposit

* fix tests using update spot market balances too

Author: moosecat2

programs/drift/src/instructions/admin.rs

@@ -2074,6 +2074,12 @@ pub fn handle_deposit_into_perp_market_fee_pool<'c: 'info, 'info>(
 
     let quote_spot_market = &mut load_mut!(ctx.accounts.quote_spot_market)?;
 
+    controller::spot_balance::update_spot_market_cumulative_interest(
+        &mut *quote_spot_market,
+        None,
+        Clock::get()?.unix_timestamp,
+    )?;
+
     controller::spot_balance::update_spot_balances(
         amount.cast::<u128>()?,
         &SpotBalanceType::Deposit,

programs/drift/src/instructions/keeper.rs

@@ -3137,6 +3137,7 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
 
     let slot = Clock::get()?.slot;
     let state = &ctx.accounts.state;
+    let now = Clock::get()?.unix_timestamp;
 
     if !state.allow_settle_lp_pool() {
         msg!("settle lp pool disabled");
@@ -3147,7 +3148,7 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
     let amm_cache_key = &ctx.accounts.amm_cache.key();
     let mut amm_cache: AccountZeroCopyMut<'_, CacheInfo, _> =
         ctx.accounts.amm_cache.load_zc_mut()?;
-    let quote_market = &ctx.accounts.quote_market.load_mut()?;
+    let quote_market = &mut ctx.accounts.quote_market.load_mut()?;
     let mut quote_constituent = ctx.accounts.constituent.load_mut()?;
     let constituent_token_account = &mut ctx.accounts.constituent_quote_token_account;
     let mut lp_pool = ctx.accounts.lp_pool.load_mut()?;
@@ -3180,9 +3181,14 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
         None,
     )?;
 
-    let precision_increase = SPOT_BALANCE_PRECISION.safe_div(QUOTE_PRECISION)?;
     let mint = Some(*ctx.accounts.mint.clone());
 
+    controller::spot_balance::update_spot_market_cumulative_interest(
+        &mut *quote_market,
+        None,
+        now,
+    )?;
+
     for (_, perp_market_loader) in perp_market_map.0.iter() {
         let mut perp_market = perp_market_loader.load_mut()?;
         if perp_market.lp_status == 0 {
@@ -3277,7 +3283,11 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
         }
 
         // Update market pools
-        update_perp_market_pools(&mut perp_market, &settlement_result, precision_increase)?;
+        update_perp_market_pools_and_quote_market_balance(
+            &mut perp_market,
+            &settlement_result,
+            quote_market,
+        )?;
 
         // Calculate new quote owed amount
         let new_quote_owed = match settlement_result.direction {
@@ -3314,6 +3324,7 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
     }
 
     // Final validation
+    ctx.accounts.quote_token_vault.reload()?;
     math::spot_withdraw::validate_spot_market_vault_amount(
         quote_market,
         ctx.accounts.quote_token_vault.amount,

programs/drift/src/math/lp_pool.rs

@@ -2,6 +2,7 @@ pub mod perp_lp_pool_settlement {
     use core::slice::Iter;
     use std::iter::Peekable;
 
+    use crate::state::spot_market::SpotBalanceType;
     use crate::{
         math::safe_math::SafeMath,
         state::{
@@ -124,28 +125,39 @@ pub mod perp_lp_pool_settlement {
     }
 
     // Market state updates
-    pub fn update_perp_market_pools(
+    pub fn update_perp_market_pools_and_quote_market_balance(
         perp_market: &mut PerpMarket,
         result: &SettlementResult,
-        precision_increase: u128,
+        quote_spot_market: &mut SpotMarket,
     ) -> Result<()> {
         match result.direction {
             SettlementDirection::FromLpPool => {
-                perp_market.amm.fee_pool.increase_balance(
-                    (result.amount_transferred as u128).safe_mul(precision_increase)?,
+                controller::spot_balance::update_spot_balances(
+                    (result.amount_transferred as u128),
+                    &SpotBalanceType::Deposit,
+                    quote_spot_market,
+                    &mut perp_market.amm.fee_pool,
+                    false,
                 )?;
             }
             SettlementDirection::ToLpPool => {
                 if result.fee_pool_used > 0 {
-                    perp_market
-                        .amm
-                        .fee_pool
-                        .decrease_balance(result.fee_pool_used.safe_mul(precision_increase)?)?;
+                    controller::spot_balance::update_spot_balances(
+                        result.fee_pool_used,
+                        &SpotBalanceType::Borrow,
+                        quote_spot_market,
+                        &mut perp_market.amm.fee_pool,
+                        true,
+                    )?;
                 }
                 if result.pnl_pool_used > 0 {
-                    perp_market
-                        .pnl_pool
-                        .decrease_balance(result.pnl_pool_used.safe_mul(precision_increase)?)?;
+                    controller::spot_balance::update_spot_balances(
+                        result.pnl_pool_used,
+                        &SpotBalanceType::Borrow,
+                        quote_spot_market,
+                        &mut perp_market.pnl_pool,
+                        true,
+                    )?;
                 }
             }
             SettlementDirection::None => {}

sdk/src/adminClient.ts

@@ -5870,7 +5870,7 @@ export class AdminClient extends DriftClient {
 		const depositIx = await this.getDepositToProgramVaultIx(
 			lpPoolName,
 			depositMarketIndex,
-			amountToDeposit,
+			amountToDeposit
 		);
 
 		const tx = await this.buildTransaction([depositIx]);

sdk/src/constituentMap/constituentMap.ts

@@ -40,10 +40,12 @@ export interface ConstituentMapInterface {
 	has(key: string): boolean;
 	get(key: string): ConstituentAccount | undefined;
 	getFromSpotMarketIndex(
-		spotMarketIndex: number): ConstituentAccount | undefined;
+		spotMarketIndex: number
+	): ConstituentAccount | undefined;
 	getFromConstituentIndex(
-		constituentIndex: number): ConstituentAccount | undefined;
-		
+		constituentIndex: number
+	): ConstituentAccount | undefined;
+
 	getWithSlot(key: string): DataAndSlot<ConstituentAccount> | undefined;
 	mustGet(key: string): Promise<ConstituentAccount>;
 	mustGetWithSlot(key: string): Promise<DataAndSlot<ConstituentAccount>>;
@@ -180,12 +182,16 @@ export class ConstituentMap implements ConstituentMapInterface {
 		return this.constituentMap.get(key)?.data;
 	}
 
-	public getFromConstituentIndex(constituentIndex: number): ConstituentAccount | undefined {
+	public getFromConstituentIndex(
+		constituentIndex: number
+	): ConstituentAccount | undefined {
 		const key = this.constituentIndexToKeyMap.get(constituentIndex);
 		return key ? this.get(key) : undefined;
 	}
 
-	public getFromSpotMarketIndex(spotMarketIndex: number): ConstituentAccount | undefined {
+	public getFromSpotMarketIndex(
+		spotMarketIndex: number
+	): ConstituentAccount | undefined {
 		const key = this.spotMarketIndexToKeyMap.get(spotMarketIndex);
 		return key ? this.get(key) : undefined;
 	}
@@ -263,13 +269,7 @@ export class ConstituentMap implements ConstituentMapInterface {
 				slot,
 			});
 		}
-		this.constituentIndexToKeyMap.set(
-			constituentAccount.constituentIndex,
-			key
-		);
-		this.spotMarketIndexToKeyMap.set(
-			constituentAccount.spotMarketIndex,
-			key
-		);
+		this.constituentIndexToKeyMap.set(constituentAccount.constituentIndex, key);
+		this.spotMarketIndexToKeyMap.set(constituentAccount.spotMarketIndex, key);
 	}
 }

tests/lpPool.ts

@@ -984,7 +984,9 @@ describe('LP Pool', () => {
 		console.log('feePoolBalanceBefore', feePoolBalance0.toString());
 		console.log('feePoolBalanceAfter', feePoolBalanceAfter.toString());
 		// Fee pool can cover it all in first perp market
-		assert(feePoolBalance0.sub(feePoolBalanceAfter).eq(expectedTransfer0));
+		expect(
+			feePoolBalance0.sub(feePoolBalanceAfter).toNumber()
+		).to.be.approximately(expectedTransfer0.toNumber(), 1);
 
 		// Constituent sync worked successfully
 		constituent = (await adminClient.program.account.constituent.fetch(
@@ -1110,12 +1112,13 @@ describe('LP Pool', () => {
 				new BN(constituentUSDCBalanceBefore.toString())
 			)
 		);
-		assert(
-			ammCache.cache[0].quoteOwedFromLpPool.eq(
-				expectedTransferAmount.sub(
-					new BN(constituentUSDCBalanceBefore.toString())
-				)
-			)
+		expect(
+			ammCache.cache[0].quoteOwedFromLpPool.toNumber()
+		).to.be.approximately(
+			expectedTransferAmount
+				.sub(new BN(constituentUSDCBalanceBefore.toString()))
+				.toNumber(),
+			1
 		);
 		assert(
 			adminClient
@@ -1471,7 +1474,6 @@ describe('LP Pool', () => {
 			await adminClient.settlePerpToLpPool(encodeName(lpPoolName), [0, 1, 2]);
 			assert(false, 'Should have thrown');
 		} catch (e) {
-			console.log(e);
 			assert(e.message.includes('0x18bd'));
 		}