testing: ix: settle perp to dlp, insufficient balance edge case and improvements (#1688)

* finish edge case test

* aum check also passes

* prettify

Author: moosecat2

programs/drift/src/instructions/admin.rs

@@ -1141,12 +1141,12 @@ pub fn handle_update_init_amm_cache_info<'c: 'info, 'info>(
             .amm
             .historical_oracle_data
             .last_oracle_price_twap;
-        cache.last_fee_pool_balance = get_token_amount(
+        cache.last_fee_pool_token_amount = get_token_amount(
             perp_market.amm.fee_pool.scaled_balance,
             &quote_market,
             perp_market.amm.fee_pool.balance_type(),
         )?;
-        cache.last_net_pnl_pool_balance = get_token_amount(
+        cache.last_net_pnl_pool_token_amount = get_token_amount(
             perp_market.pnl_pool.scaled_balance,
             &quote_market,
             perp_market.pnl_pool.balance_type(),

programs/drift/src/instructions/keeper.rs

@@ -6,7 +6,6 @@ use anchor_lang::Discriminator;
 use anchor_spl::associated_token::get_associated_token_address_with_program_id;
 use anchor_spl::token_interface::Mint;
 use anchor_spl::token_interface::{TokenAccount, TokenInterface};
-use num_integer::Integer;
 use solana_program::instruction::Instruction;
 use solana_program::pubkey;
 use solana_program::sysvar::instructions::{
@@ -36,7 +35,6 @@ use crate::math::oracle::is_oracle_valid_for_action;
 use crate::math::oracle::DriftAction;
 use crate::math::orders::{estimate_price_from_side, find_bids_and_asks_from_users};
 use crate::math::position::calculate_base_asset_value_and_pnl_with_oracle_price;
-use crate::math::safe_math::SafeDivFloor;
 use crate::math::safe_math::SafeMath;
 use crate::math::spot_balance::get_token_amount;
 use crate::math::spot_withdraw::validate_spot_market_vault_amount;
@@ -3008,12 +3006,14 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
         .cast::<i128>()?
         .safe_sub(calculate_net_user_pnl(&perp_market.amm, oracle_data.price)?)?;
 
-        let amount_available =
+        let amm_amount_available =
             net_pnl_pool_token_amount.safe_add(fee_pool_token_amount.cast::<i128>()?)?;
 
-        if cached_info.last_net_pnl_pool_balance == 0 && cached_info.last_fee_pool_balance == 0 {
-            cached_info.last_fee_pool_balance = fee_pool_token_amount;
-            cached_info.last_net_pnl_pool_balance = net_pnl_pool_token_amount;
+        if cached_info.last_net_pnl_pool_token_amount == 0
+            && cached_info.last_fee_pool_token_amount == 0
+        {
+            cached_info.last_fee_pool_token_amount = fee_pool_token_amount;
+            cached_info.last_net_pnl_pool_token_amount = net_pnl_pool_token_amount;
             continue;
         }
 
@@ -3090,16 +3090,26 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
             continue;
         }
 
-        let amount_to_send = amount_available
+        let amount_to_send = amm_amount_available
             .abs_diff(cached_info.get_last_available_amm_balance()?)
-            .safe_div_ceil(perp_market.lp_fee_transfer_scalar as u128)?;
-        if amount_available < 0 {
-            controller::token::receive(
+            .safe_div_ceil(perp_market.lp_fee_transfer_scalar as u128)?
+            .cast::<u64>()?;
+        if amm_amount_available < cached_info.get_last_available_amm_balance()? {
+            let amount_to_send = if amount_to_send > constituent_token_account.amount {
+                cached_info.quote_owed_from_lp +=
+                    amount_to_send.saturating_sub(constituent_token_account.amount) as i64;
+                constituent_token_account.amount
+            } else {
+                amount_to_send
+            };
+
+            controller::token::send_from_program_vault(
                 &ctx.accounts.token_program,
                 constituent_token_account,
                 &ctx.accounts.quote_token_vault,
                 &ctx.accounts.drift_signer,
-                amount_to_send.cast::<u64>()?,
+                state.signer_nonce,
+                amount_to_send,
                 &Some(mint),
             )?;
 
@@ -3115,58 +3125,78 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
             lp_pool.last_aum = lp_pool
                 .last_aum
                 .saturating_sub(amount_to_send.cast::<u128>()?);
-        } else {
-            controller::token::send_from_program_vault(
-                &ctx.accounts.token_program,
-                &ctx.accounts.quote_token_vault,
-                constituent_token_account,
-                &ctx.accounts.drift_signer,
-                state.signer_nonce,
-                amount_to_send.cast::<u64>()?,
-                &Some(mint),
-            )?;
 
-            // If both fees and pnl are up, take from both equally
-            let precision_increase = SPOT_BALANCE_PRECISION.safe_div(QUOTE_PRECISION)?;
-            if fee_pool_token_amount > cached_info.last_fee_pool_balance
-                && net_pnl_pool_token_amount > cached_info.last_net_pnl_pool_balance
-            {
-                let abs_scaled_fee_pool_token_delta = fee_pool_token_amount
-                    .abs_diff(cached_info.last_fee_pool_balance)
-                    .safe_div_ceil(perp_market.lp_fee_transfer_scalar as u128)?;
-
-                let abs_scaled_pnl_pool_token_delta = net_pnl_pool_token_amount
-                    .abs_diff(cached_info.last_net_pnl_pool_balance)
-                    .safe_div_ceil(perp_market.lp_fee_transfer_scalar as u128)?;
-
-                msg!(
-                    "abs scaled fee pool token delta = {} abs scaled pnl pool token delta = {}",
-                    abs_scaled_fee_pool_token_delta,
-                    abs_scaled_pnl_pool_token_delta
-                );
-                perp_market.amm.fee_pool.decrease_balance(
-                    abs_scaled_fee_pool_token_delta.safe_mul(precision_increase)?,
-                )?;
-                perp_market.pnl_pool.decrease_balance(
-                    abs_scaled_pnl_pool_token_delta.safe_mul(precision_increase)?,
+            cached_info.last_fee_pool_token_amount =
+                fee_pool_token_amount.safe_add(amount_to_send as u128)?;
+        } else {
+            let amount_to_send = if cached_info.quote_owed_from_lp > 0 {
+                if amount_to_send > cached_info.quote_owed_from_lp as u64 {
+                    cached_info.quote_owed_from_lp = 0;
+                    amount_to_send - cached_info.quote_owed_from_lp as u64
+                } else {
+                    cached_info.quote_owed_from_lp -= amount_to_send as i64;
+                    0
+                }
+            } else {
+                amount_to_send
+            };
+
+            if amount_to_send > 0 {
+                controller::token::send_from_program_vault(
+                    &ctx.accounts.token_program,
+                    &ctx.accounts.quote_token_vault,
+                    constituent_token_account,
+                    &ctx.accounts.drift_signer,
+                    state.signer_nonce,
+                    amount_to_send.cast::<u64>()?,
+                    &Some(mint),
                 )?;
-            } else if fee_pool_token_amount > cached_info.last_fee_pool_balance {
-                perp_market
-                    .amm
-                    .fee_pool
-                    .decrease_balance((amount_to_send as u128).safe_mul(precision_increase)?)?;
-            } else if net_pnl_pool_token_amount > cached_info.last_net_pnl_pool_balance {
-                perp_market
-                    .pnl_pool
-                    .decrease_balance((amount_to_send as u128).safe_mul(precision_increase)?)?;
-            }
+                // If both fees and pnl are up, take from both equally
+                let precision_increase = SPOT_BALANCE_PRECISION.safe_div(QUOTE_PRECISION)?;
+                if fee_pool_token_amount > cached_info.last_fee_pool_token_amount
+                    && net_pnl_pool_token_amount > cached_info.last_net_pnl_pool_token_amount
+                {
+                    let abs_scaled_fee_pool_token_delta = fee_pool_token_amount
+                        .abs_diff(cached_info.last_fee_pool_token_amount)
+                        .safe_div_ceil(perp_market.lp_fee_transfer_scalar as u128)?;
 
-            lp_pool.cumulative_usdc_received_from_perp_markets = lp_pool
-                .cumulative_usdc_received_from_perp_markets
-                .saturating_add(amount_to_send.cast::<u128>()?);
-            lp_pool.last_aum = lp_pool
-                .last_aum
-                .saturating_add(amount_to_send.cast::<u128>()?);
+                    let abs_scaled_pnl_pool_token_delta = net_pnl_pool_token_amount
+                        .abs_diff(cached_info.last_net_pnl_pool_token_amount)
+                        .safe_div_ceil(perp_market.lp_fee_transfer_scalar as u128)?;
+
+                    perp_market.amm.fee_pool.decrease_balance(
+                        abs_scaled_fee_pool_token_delta.safe_mul(precision_increase)?,
+                    )?;
+                    perp_market.pnl_pool.decrease_balance(
+                        abs_scaled_pnl_pool_token_delta.safe_mul(precision_increase)?,
+                    )?;
+
+                    cached_info.last_fee_pool_token_amount =
+                        fee_pool_token_amount.safe_sub(abs_scaled_fee_pool_token_delta)?;
+                    cached_info.last_net_pnl_pool_token_amount = net_pnl_pool_token_amount
+                        .safe_sub(abs_scaled_pnl_pool_token_delta.cast::<i128>()?)?;
+                } else if fee_pool_token_amount > cached_info.last_fee_pool_token_amount {
+                    perp_market
+                        .amm
+                        .fee_pool
+                        .decrease_balance((amount_to_send as u128).safe_mul(precision_increase)?)?;
+                    cached_info.last_fee_pool_token_amount =
+                        fee_pool_token_amount.safe_sub(amount_to_send as u128)?;
+                } else if net_pnl_pool_token_amount > cached_info.last_net_pnl_pool_token_amount {
+                    perp_market
+                        .pnl_pool
+                        .decrease_balance((amount_to_send as u128).safe_mul(precision_increase)?)?;
+                    cached_info.last_net_pnl_pool_token_amount =
+                        net_pnl_pool_token_amount.safe_sub(amount_to_send.cast::<i128>()?)?;
+                }
+
+                lp_pool.cumulative_usdc_received_from_perp_markets = lp_pool
+                    .cumulative_usdc_received_from_perp_markets
+                    .saturating_add(amount_to_send.cast::<u128>()?);
+                lp_pool.last_aum = lp_pool
+                    .last_aum
+                    .saturating_add(amount_to_send.cast::<u128>()?);
+            }
         }
 
         lp_pool.last_aum_ts = clock.unix_timestamp;
@@ -3175,8 +3205,6 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
         constituent_token_account.reload()?;
         constituent.sync_token_balance(constituent_token_account.amount);
 
-        cached_info.last_fee_pool_balance = fee_pool_token_amount;
-        cached_info.last_net_pnl_pool_balance = net_pnl_pool_token_amount;
         cached_info.last_settle_amount = amount_to_send.cast::<u64>()?;
         cached_info.last_settle_ts = Clock::get()?.unix_timestamp;
     }
@@ -3197,8 +3225,6 @@ pub fn handle_update_amm_cache<'c: 'info, 'info>(
     let mut amm_cache: AccountZeroCopyMut<'_, CacheInfo, _> =
         ctx.accounts.amm_cache.load_zc_mut()?;
 
-    let quote_market = &ctx.accounts.quote_market.load()?;
-
     let expected_pda = &Pubkey::create_program_address(
         &[
             AMM_POSITIONS_CACHE.as_ref(),

programs/drift/src/instructions/lp_pool.rs

@@ -5,9 +5,8 @@ use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
 
 use crate::{
     controller::{
-        self,
+        self, lp,
         spot_balance::update_spot_balances,
-        lp,
         token::{burn_tokens, mint_tokens},
     },
     error::ErrorCode,

programs/drift/src/state/lp_pool.rs

@@ -23,6 +23,8 @@ pub const CONSTITUENT_TARGET_BASE_PDA_SEED: &str = "constituent_target_base";
 pub const CONSTITUENT_VAULT_PDA_SEED: &str = "CONSTITUENT_VAULT";
 pub const LP_POOL_TOKEN_VAULT_PDA_SEED: &str = "LP_POOL_TOKEN_VAULT";
 
+pub const MAX_SWAP_FEE: i64 = 75_000; // 0.75% in PERCENTAGE_PRECISION
+
 #[cfg(test)]
 mod tests;
 
@@ -292,7 +294,7 @@ impl LPPool {
             out_spot_market,
             out_oracle,
             out_constituent,
-            out_amount.cast::<i64>()?,
+            out_amount.cast::<i64>()?.safe_mul(-1_i64)?,
             out_target_weight,
         )?;
         let out_fee_amount = out_amount
@@ -326,15 +328,26 @@ impl LPPool {
             target_weight
         );
 
+        let adjusted_aum = self
+            .last_aum
+            .cast::<i128>()?
+            .safe_add(
+                amount
+                    .cast::<i128>()?
+                    .safe_mul(oracle.price.cast::<i128>()?)?
+                    .safe_div(10_i128.pow(spot_market.decimals as u32))?,
+            )?
+            .cast::<u128>()?;
         let weight_after =
-            constituent.get_weight(oracle.price, spot_market, amount, self.last_aum)?;
+            constituent.get_weight(oracle.price, spot_market, amount, adjusted_aum)?;
         msg!(
             "constituent {}: weight_after: {} target_weight: {}",
             constituent.constituent_index,
             weight_after,
             target_weight
         );
         let fee = constituent.get_fee_to_charge(weight_after, target_weight)?;
+        let fee = fee.min(MAX_SWAP_FEE);
 
         Ok(fee)
     }

programs/drift/src/state/perp_market.rs

@@ -1691,22 +1691,23 @@ pub struct AmmCache {
 #[derive(AnchorSerialize, AnchorDeserialize, Debug)]
 #[repr(C)]
 pub struct CacheInfo {
+    pub last_fee_pool_token_amount: u128,
+    pub last_net_pnl_pool_token_amount: i128,
     /// BASE PRECISION
     pub position: i64,
     pub slot: u64,
     pub max_confidence_interval_multiplier: u64,
     pub last_oracle_price_twap: i64,
+    pub last_settle_amount: u64,
+    pub last_settle_ts: i64,
+    pub quote_owed_from_lp: i64,
     pub oracle_price: i64,
     pub oracle_confidence: u64,
     pub oracle_delay: i64,
     pub oracle_slot: u64,
-    pub oracle: Pubkey,
-    pub last_fee_pool_balance: u128,
-    pub last_net_pnl_pool_balance: i128,
-    pub last_settle_amount: u64,
-    pub last_settle_ts: i64,
     pub oracle_source: u8,
     _padding: [u8; 7],
+    pub oracle: Pubkey,
 }
 
 impl Size for CacheInfo {
@@ -1724,13 +1725,14 @@ impl Default for CacheInfo {
             oracle_confidence: 0u64,
             oracle_delay: 0i64,
             oracle_slot: 0u64,
+            _padding: [0u8; 7],
             oracle: Pubkey::default(),
-            last_fee_pool_balance: 0u128,
-            last_net_pnl_pool_balance: 0i128,
+            last_fee_pool_token_amount: 0u128,
+            last_net_pnl_pool_token_amount: 0i128,
             last_settle_amount: 0u64,
             last_settle_ts: 0i64,
             oracle_source: 0u8,
-            _padding: [0u8; 7],
+            quote_owed_from_lp: 0i64,
         }
     }
 }
@@ -1747,9 +1749,9 @@ impl CacheInfo {
 
     pub fn get_last_available_amm_balance(&self) -> DriftResult<i128> {
         let last_available_balance = self
-            .last_fee_pool_balance
+            .last_fee_pool_token_amount
             .cast::<i128>()?
-            .safe_add(self.last_net_pnl_pool_balance)?;
+            .safe_add(self.last_net_pnl_pool_token_amount)?;
         Ok(last_available_balance)
     }
 }