aum cant go below zero (#1890)

* aum cant go below zero

* keep it signed

Author: moosecat2

programs/drift/src/instructions/lp_admin.rs

@@ -1,5 +1,3 @@
-use crate::state::perp_market_map::MarketSet;
-use crate::{controller, load_mut};
 use crate::controller::token::{receive, send_from_program_vault_with_signature_seeds};
 use crate::error::ErrorCode;
 use crate::ids::{admin_hot_wallet, lp_pool_swap_wallet};
@@ -14,9 +12,11 @@ use crate::state::lp_pool::{
     CONSTITUENT_VAULT_PDA_SEED,
 };
 use crate::state::perp_market::PerpMarket;
+use crate::state::perp_market_map::MarketSet;
 use crate::state::spot_market::SpotMarket;
 use crate::state::state::State;
 use crate::validate;
+use crate::{controller, load_mut};
 use anchor_lang::prelude::*;
 use anchor_lang::Discriminator;
 use anchor_spl::associated_token::AssociatedToken;
@@ -893,7 +893,7 @@ pub fn handle_update_perp_market_lp_pool_status(
     msg!("perp market {}", perp_market.market_index);
     perp_market.lp_status = lp_status;
     amm_cache.update_perp_market_fields(&perp_market)?;
-    
+
     Ok(())
 }
 
@@ -980,7 +980,6 @@ pub fn handle_override_amm_cache_info<'c: 'info, 'info>(
     Ok(())
 }
 
-
 #[derive(Accounts)]
 #[instruction(
     name: [u8; 32],
@@ -1136,7 +1135,7 @@ pub struct UpdateConstituentParams<'info> {
 pub struct UpdateConstituentStatus<'info> {
     #[account(
         mut,
-        constraint = admin.key() == state.admin 
+        constraint = admin.key() == state.admin
     )]
     pub admin: Signer<'info>,
     pub state: Box<Account<'info, State>>,

programs/drift/src/instructions/lp_pool.rs

@@ -220,6 +220,7 @@ pub fn handle_update_lp_pool_aum<'c: 'info, 'info>(
     )?;
 
     // Set USDC stable weight
+    msg!("aum: {}", aum);
     let total_stable_target_base = aum
         .cast::<i128>()?
         .safe_sub(crypto_delta.abs())?
@@ -808,16 +809,15 @@ pub fn handle_lp_pool_add_liquidity<'c: 'info, 'info>(
 
     ctx.accounts.lp_mint.reload()?;
     let lp_price_after = lp_pool.get_price(lp_pool.token_supply)?;
-    if lp_price_before != 0 {
-        let price_diff_percent = lp_price_after
-            .abs_diff(lp_price_before)
-            .safe_mul(PERCENTAGE_PRECISION)?
-            .safe_div(lp_price_before)?;
+    let price_diff = (lp_price_after.cast::<i128>()?).safe_sub(lp_price_before.cast::<i128>()?)?;
 
+    if lp_price_before > 0 && price_diff.signum() != 0 && in_fee_amount.signum() != 0 {
         validate!(
-            price_diff_percent <= PERCENTAGE_PRECISION / 5,
+            price_diff.signum() == in_fee_amount.signum() || price_diff == 0,
             ErrorCode::LpInvariantFailed,
-            "Removing liquidity resulted in DLP token difference of > 5%"
+            "Adding liquidity resulted in price direction != fee sign, price_diff: {}, in_fee_amount: {}",
+            price_diff,
+            in_fee_amount
         )?;
     }
 
@@ -1192,15 +1192,14 @@ pub fn handle_lp_pool_remove_liquidity<'c: 'info, 'info>(
     ctx.accounts.lp_mint.reload()?;
     let lp_price_after = lp_pool.get_price(lp_pool.token_supply)?;
 
-    if lp_price_after != 0 {
-        let price_diff_percent = lp_price_after
-            .abs_diff(lp_price_before)
-            .safe_mul(PERCENTAGE_PRECISION)?
-            .safe_div(lp_price_before)?;
+    let price_diff = (lp_price_after.cast::<i128>()?).safe_sub(lp_price_before.cast::<i128>()?)?;
+    if price_diff.signum() != 0 && out_fee_amount.signum() != 0 {
         validate!(
-            price_diff_percent <= PERCENTAGE_PRECISION / 5,
+            price_diff.signum() == out_fee_amount.signum(),
             ErrorCode::LpInvariantFailed,
-            "Removing liquidity resulted in DLP token difference of > 5%"
+            "Removing liquidity resulted in price direction != fee sign, price_diff: {}, out_fee_amount: {}",
+            price_diff,
+            out_fee_amount
         )?;
     }
 

programs/drift/src/math/lp_pool.rs

@@ -79,7 +79,10 @@ pub mod perp_lp_pool_settlement {
         let amount_to_send = ctx
             .quote_owed_from_lp
             .cast::<u64>()?
-            .min(ctx.quote_constituent_token_balance)
+            .min(
+                ctx.quote_constituent_token_balance
+                    .saturating_sub(QUOTE_PRECISION_U64),
+            )
             .min(ctx.max_settle_quote_amount);
 
         Ok(SettlementResult {

programs/drift/src/state/lp_pool.rs

@@ -4,7 +4,7 @@ use crate::error::{DriftResult, ErrorCode};
 use crate::math::casting::Cast;
 use crate::math::constants::{
     BASE_PRECISION_I128, PERCENTAGE_PRECISION, PERCENTAGE_PRECISION_I128, PERCENTAGE_PRECISION_I64,
-    PERCENTAGE_PRECISION_U64, PRICE_PRECISION, QUOTE_PRECISION_I128,
+    PERCENTAGE_PRECISION_U64, PRICE_PRECISION, QUOTE_PRECISION_I128, QUOTE_PRECISION_U64,
 };
 use crate::math::safe_math::SafeMath;
 use crate::math::safe_unwrap::SafeUnwrap;
@@ -300,13 +300,17 @@ impl LPPool {
         &self,
         out_spot_market: &SpotMarket,
         out_constituent: &Constituent,
-        lp_burn_amount: u64,
+        lp_to_burn: u64,
         out_oracle: &OraclePriceData,
         out_target_weight: i64,
         dlp_total_supply: u64,
     ) -> DriftResult<(u64, u128, i64, i128)> {
         let lp_fee_to_charge_pct = self.min_mint_fee;
-        // let lp_fee_to_charge_pct = self.get_mint_redeem_fee(now, false)?;
+        let mut lp_burn_amount = lp_to_burn;
+        if dlp_total_supply.saturating_sub(lp_burn_amount) <= QUOTE_PRECISION_U64 {
+            lp_burn_amount = dlp_total_supply.saturating_sub(QUOTE_PRECISION_U64);
+        }
+
         let lp_fee_to_charge = lp_burn_amount
             .cast::<i128>()?
             .safe_mul(lp_fee_to_charge_pct.cast::<i128>()?)?
@@ -676,16 +680,26 @@ impl LPPool {
                     .cast::<i64>()?;
                 crypto_delta = crypto_delta.safe_add(constituent_target_notional.cast()?)?;
             }
-            aum = aum.safe_add(constituent_aum)?;
+            aum = aum.saturating_add(constituent_aum);
         }
 
         msg!("Aum before quote owed from lp pool: {}", aum);
 
+        let mut total_quote_owed: i128 = 0;
         for cache_datum in amm_cache.iter() {
-            aum = aum.saturating_sub(cache_datum.quote_owed_from_lp_pool as i128);
+            total_quote_owed =
+                total_quote_owed.safe_add(cache_datum.quote_owed_from_lp_pool as i128)?;
+        }
+
+        if total_quote_owed > 0 {
+            aum = aum
+                .saturating_sub(total_quote_owed as i128)
+                .max(QUOTE_PRECISION_I128);
+        } else if total_quote_owed < 0 {
+            aum = aum.saturating_add((-total_quote_owed) as i128);
         }
 
-        let aum_u128 = aum.max(0i128).cast::<u128>()?;
+        let aum_u128 = aum.max(0).cast::<u128>()?;
         self.last_aum = aum_u128;
         self.last_aum_slot = slot;
 

programs/drift/src/state/lp_pool/tests.rs

@@ -432,7 +432,7 @@ mod tests {
         let mut constituents_indexes_and_decimals_and_prices =
             vec![ConstituentIndexAndDecimalAndPrice {
                 constituent_index: 1,
-                decimals: 6,
+                decimals: 9,
                 price: 142_000_000,
             }];
 
@@ -459,7 +459,7 @@ mod tests {
             .unwrap();
 
         assert_eq!(target_zc_mut.len(), 1);
-        assert_eq!(target_zc_mut.get(0).target_base, -1_000); // despite no aum, desire to reach target
+        assert_eq!(target_zc_mut.get(0).target_base, -1_000_000); // despite no aum, desire to reach target
         assert_eq!(target_zc_mut.get(0).last_slot, now_ts);
     }
 }

tests/lpPool.ts

@@ -685,6 +685,7 @@ describe('LP Pool', () => {
 			lpPoolKey
 		)) as LPPoolAccount;
 
+		console.log(lpPool.lastAum.toString());
 		assert(lpPool.lastAum.eq(new BN(1000).mul(QUOTE_PRECISION)));
 
 		// Should fail if we dont pass in the second constituent
@@ -1218,35 +1219,36 @@ describe('LP Pool', () => {
 			constituentVaultPublicKey
 		);
 
-		// Should have written fee pool amount owed to the amm cache and new constituent usdc balane should be 0
+		// Should have written fee pool amount owed to the amm cache and new constituent usdc balane should just be the quote precision to leave aum > 0
 		ammCache = (await adminClient.program.account.ammCache.fetch(
 			getAmmCachePublicKey(program.programId)
 		)) as AmmCache;
 		// No more usdc left in the constituent vault
-		assert(constituent.vaultTokenBalance.eq(ZERO));
-		assert(new BN(constituentVault.amount.toString()).eq(ZERO));
+		assert(constituent.vaultTokenBalance.eq(QUOTE_PRECISION));
+		assert(new BN(constituentVault.amount.toString()).eq(QUOTE_PRECISION));
 
 		// Should have recorded the amount left over to the amm cache and increased the amount in the fee pool
 		assert(
 			ammCache.cache[0].lastFeePoolTokenAmount.eq(
-				new BN(constituentUSDCBalanceBefore.toString())
+				new BN(constituentUSDCBalanceBefore.toString()).sub(QUOTE_PRECISION)
 			)
 		);
 		expect(
 			ammCache.cache[0].quoteOwedFromLpPool.toNumber()
 		).to.be.approximately(
 			expectedTransferAmount
 				.sub(new BN(constituentUSDCBalanceBefore.toString()))
+				.add(QUOTE_PRECISION)
 				.toNumber(),
 			1
 		);
 		assert(
 			adminClient
 				.getPerpMarketAccount(0)
 				.amm.feePool.scaledBalance.eq(
-					new BN(constituentUSDCBalanceBefore.toString()).mul(
-						SPOT_MARKET_BALANCE_PRECISION.div(QUOTE_PRECISION)
-					)
+					new BN(constituentUSDCBalanceBefore.toString())
+						.sub(QUOTE_PRECISION)
+						.mul(SPOT_MARKET_BALANCE_PRECISION.div(QUOTE_PRECISION))
 				)
 		);
 
@@ -1255,7 +1257,7 @@ describe('LP Pool', () => {
 		lpPool = (await adminClient.program.account.lpPool.fetch(
 			lpPoolKey
 		)) as LPPoolAccount;
-		assert(lpPool.lastAum.eq(ZERO));
+		assert(lpPool.lastAum.eq(QUOTE_PRECISION));
 	});
 
 	it('perp market will not transfer with the constituent vault if it is owed from dlp', async () => {
@@ -1303,8 +1305,8 @@ describe('LP Pool', () => {
 		expect(
 			ammCache.cache[0].quoteOwedFromLpPool.toNumber()
 		).to.be.approximately(owedAmount.divn(2).toNumber(), 1);
-		assert(constituent.vaultTokenBalance.eq(ZERO));
-		assert(lpPool.lastAum.eq(ZERO));
+		assert(constituent.vaultTokenBalance.eq(QUOTE_PRECISION));
+		assert(lpPool.lastAum.eq(QUOTE_PRECISION));
 
 		// Deposit here to DLP to make sure aum calc work with perp market debt
 		await overWriteMintAccount(
@@ -1368,7 +1370,7 @@ describe('LP Pool', () => {
 		const balanceBefore = constituent.vaultTokenBalance;
 		const owedAmount = ammCache.cache[0].quoteOwedFromLpPool;
 
-		// Give the perp market half of its owed amount
+		// Give the perp market double of its owed amount
 		const perpMarket = adminClient.getPerpMarketAccount(0);
 		perpMarket.amm.feePool.scaledBalance =
 			perpMarket.amm.feePool.scaledBalance.add(

tests/lpPoolCUs.ts

@@ -103,11 +103,10 @@ describe('LP Pool', () => {
 	let bankrunContextWrapper: BankrunContextWrapper;
 	let bulkAccountLoader: TestBulkAccountLoader;
 
-	let userLpTokenAccount: PublicKey;
+	let _userLpTokenAccount: PublicKey;
 	let adminClient: TestClient;
 	let usdcMint: Keypair;
 	let spotTokenMint: Keypair;
-	let spotMarketOracle: PublicKey;
 	let spotMarketOracle2: PublicKey;
 
 	let adminKeypair: Keypair;
@@ -166,7 +165,6 @@ describe('LP Pool', () => {
 
 		usdcMint = await mockUSDCMint(bankrunContextWrapper);
 		spotTokenMint = await mockUSDCMint(bankrunContextWrapper);
-		spotMarketOracle = await mockOracleNoProgram(bankrunContextWrapper, 200);
 		spotMarketOracle2 = await mockOracleNoProgram(bankrunContextWrapper, 200);
 
 		const keypair = new Keypair();
@@ -267,7 +265,7 @@ describe('LP Pool', () => {
 			lpPoolKey
 		)) as LPPoolAccount;
 
-		userLpTokenAccount = await mockAtaTokenAccountForMint(
+		_userLpTokenAccount = await mockAtaTokenAccountForMint(
 			bankrunContextWrapper,
 			lpPool.mint,
 			new BN(0),