address some perp comments

Author: moosecat2

programs/drift/src/error.rs

@@ -672,6 +672,10 @@ pub enum ErrorCode {
     MaxDlpAumBreached,
     #[msg("Settle Lp Pool Disabled")]
     SettleLpPoolDisabled,
+    #[msg("Mint/Redeem Lp Pool Disabled")]
+    MintRedeemLpPoolDisabled,
+    #[msg("Settlement amount exceeded")]
+    LpPoolSettleInvariantBreached,
 }
 
 #[macro_export]

programs/drift/src/instructions/admin.rs

@@ -80,7 +80,9 @@ use crate::state::spot_market::{
     SpotMarket, TokenProgramFlag,
 };
 use crate::state::spot_market_map::get_writable_spot_market_set;
-use crate::state::state::{ExchangeStatus, FeeStructure, OracleGuardRails, State};
+use crate::state::state::{
+    ExchangeStatus, FeeStructure, LpPoolFeatureBitFlags, OracleGuardRails, State,
+};
 use crate::state::traits::Size;
 use crate::state::user::{User, UserStats};
 use crate::validate;
@@ -133,7 +135,8 @@ pub fn handle_initialize(ctx: Context<Initialize>) -> Result<()> {
         max_number_of_sub_accounts: 0,
         max_initialize_user_fee: 0,
         feature_bit_flags: 0,
-        padding: [0; 9],
+        lp_pool_feature_bit_flags: 0,
+        padding: [0; 8],
     };
 
     Ok(())
@@ -4761,12 +4764,24 @@ pub fn handle_initialize_lp_pool(
     max_settle_quote_amount_per_market: u64,
 ) -> Result<()> {
     let mut lp_pool = ctx.accounts.lp_pool.load_init()?;
-    let mint = ctx.accounts.mint.key();
+    let mint = &ctx.accounts.mint;
+
+    validate!(
+        mint.decimals == 6,
+        ErrorCode::DefaultError,
+        "lp mint must have 6 decimals"
+    )?;
+
+    validate!(
+        mint.mint_authority == Some(ctx.accounts.drift_signer.key()).into(),
+        ErrorCode::DefaultError,
+        "lp mint must have drift_signer as mint authority"
+    )?;
 
     *lp_pool = LPPool {
         name,
         pubkey: ctx.accounts.lp_pool.key(),
-        mint,
+        mint: mint.key(),
         constituents: 0,
         max_aum,
         last_aum: 0,
@@ -5190,11 +5205,13 @@ pub fn handle_update_feature_bit_flags_settle_lp_pool(
             "Only state admin can re-enable after kill switch"
         )?;
 
-        msg!("Setting third bit to 1, enabling settle LP pool");
-        state.feature_bit_flags = state.feature_bit_flags | (FeatureBitFlags::SettleLpPool as u8);
+        msg!("Setting first bit to 1, enabling settle LP pool");
+        state.lp_pool_feature_bit_flags =
+            state.lp_pool_feature_bit_flags | (LpPoolFeatureBitFlags::SettleLpPool as u8);
     } else {
-        msg!("Setting third bit to 0, disabling settle LP pool");
-        state.feature_bit_flags = state.feature_bit_flags & !(FeatureBitFlags::SettleLpPool as u8);
+        msg!("Setting first bit to 0, disabling settle LP pool");
+        state.lp_pool_feature_bit_flags =
+            state.lp_pool_feature_bit_flags & !(LpPoolFeatureBitFlags::SettleLpPool as u8);
     }
     Ok(())
 }
@@ -5211,11 +5228,36 @@ pub fn handle_update_feature_bit_flags_swap_lp_pool(
             "Only state admin can re-enable after kill switch"
         )?;
 
-        msg!("Setting fourth bit to 1, enabling swapping with LP pool");
-        state.feature_bit_flags = state.feature_bit_flags | (FeatureBitFlags::SwapLpPool as u8);
+        msg!("Setting second bit to 1, enabling swapping with LP pool");
+        state.lp_pool_feature_bit_flags =
+            state.lp_pool_feature_bit_flags | (LpPoolFeatureBitFlags::SwapLpPool as u8);
+    } else {
+        msg!("Setting second bit to 0, disabling swapping with LP pool");
+        state.lp_pool_feature_bit_flags =
+            state.lp_pool_feature_bit_flags & !(LpPoolFeatureBitFlags::SwapLpPool as u8);
+    }
+    Ok(())
+}
+
+pub fn handle_update_feature_bit_flags_mint_redeem_lp_pool(
+    ctx: Context<HotAdminUpdateState>,
+    enable: bool,
+) -> Result<()> {
+    let state = &mut ctx.accounts.state;
+    if enable {
+        validate!(
+            ctx.accounts.admin.key().eq(&state.admin),
+            ErrorCode::DefaultError,
+            "Only state admin can re-enable after kill switch"
+        )?;
+
+        msg!("Setting third bit to 1, enabling minting and redeeming with LP pool");
+        state.lp_pool_feature_bit_flags =
+            state.lp_pool_feature_bit_flags | (LpPoolFeatureBitFlags::MintRedeemLpPool as u8);
     } else {
-        msg!("Setting fourth bit to 0, disabling swapping with LP pool");
-        state.feature_bit_flags = state.feature_bit_flags & !(FeatureBitFlags::SwapLpPool as u8);
+        msg!("Setting third bit to 0, disabling minting and redeeming with LP pool");
+        state.lp_pool_feature_bit_flags =
+            state.lp_pool_feature_bit_flags & !(LpPoolFeatureBitFlags::MintRedeemLpPool as u8);
     }
     Ok(())
 }
@@ -6866,7 +6908,6 @@ pub struct InitializeLpPool<'info> {
         payer = admin
     )]
     pub lp_pool: AccountLoader<'info, LPPool>,
-
     pub mint: Account<'info, anchor_spl::token::Mint>,
 
     #[account(

programs/drift/src/instructions/keeper.rs

@@ -3223,17 +3223,12 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
                 &SpotBalanceType::Deposit,
             )?,
             quote_market,
+            max_settle_quote_amount: lp_pool.max_settle_quote_amount,
         };
 
         // Calculate settlement
-        let mut settlement_result = calculate_settlement_amount(&settlement_ctx)?;
-
-        // If transfering from perp market, dont do more than the max allowed
-        if settlement_result.direction == SettlementDirection::ToLpPool {
-            settlement_result.amount_transferred = settlement_result
-                .amount_transferred
-                .min(lp_pool.max_settle_quote_amount);
-        }
+        let settlement_result = calculate_settlement_amount(&settlement_ctx)?;
+        validate_settlement_amount(&settlement_ctx, &settlement_result)?;
 
         if settlement_result.direction == SettlementDirection::None {
             continue;

programs/drift/src/instructions/lp_pool.rs

@@ -626,10 +626,16 @@ pub fn handle_lp_pool_add_liquidity<'c: 'info, 'info>(
         ErrorCode::UnauthorizedDlpAuthority,
         "User is not whitelisted for DLP deposits"
     )?;
+    let state = &ctx.accounts.state;
+
+    validate!(
+        state.allow_mint_redeem_lp_pool(),
+        ErrorCode::MintRedeemLpPoolDisabled,
+        "Mint/redeem LP pool is disabled"
+    )?;
 
     let slot = Clock::get()?.slot;
     let now = Clock::get()?.unix_timestamp;
-    let state = &ctx.accounts.state;
     let mut lp_pool = ctx.accounts.lp_pool.load_mut()?;
 
     let lp_price_before = lp_pool.get_price(ctx.accounts.lp_mint.supply)?;
@@ -934,6 +940,13 @@ pub fn handle_lp_pool_remove_liquidity<'c: 'info, 'info>(
     let slot = Clock::get()?.slot;
     let now = Clock::get()?.unix_timestamp;
     let state = &ctx.accounts.state;
+
+    validate!(
+        state.allow_mint_redeem_lp_pool(),
+        ErrorCode::MintRedeemLpPoolDisabled,
+        "Mint/redeem LP pool is disabled"
+    )?;
+
     let mut lp_pool = ctx.accounts.lp_pool.load_mut()?;
 
     let lp_price_before = lp_pool.get_price(ctx.accounts.lp_mint.supply)?;

programs/drift/src/lib.rs

@@ -1854,6 +1854,13 @@ pub mod drift {
         handle_update_feature_bit_flags_swap_lp_pool(ctx, enable)
     }
 
+    pub fn update_feature_bit_flags_mint_redeem_lp_pool(
+        ctx: Context<HotAdminUpdateState>,
+        enable: bool,
+    ) -> Result<()> {
+        handle_update_feature_bit_flags_mint_redeem_lp_pool(ctx, enable)
+    }
+
     pub fn initialize_constituent<'info>(
         ctx: Context<'_, '_, '_, 'info, InitializeConstituent<'info>>,
         spot_market_index: u16,

programs/drift/src/math/lp_pool.rs

@@ -2,12 +2,14 @@ pub mod perp_lp_pool_settlement {
     use core::slice::Iter;
     use std::iter::Peekable;
 
+    use crate::error::ErrorCode;
+    use crate::math::casting::Cast;
     use crate::state::spot_market::SpotBalanceType;
     use crate::{
         math::safe_math::SafeMath,
         state::{
             perp_market::{CacheInfo, PerpMarket},
-            spot_market::{SpotBalance, SpotMarket},
+            spot_market::SpotMarket,
         },
         *,
     };
@@ -34,6 +36,7 @@ pub mod perp_lp_pool_settlement {
         pub fee_pool_balance: u128,
         pub pnl_pool_balance: u128,
         pub quote_market: &'a SpotMarket,
+        pub max_settle_quote_amount: u64,
     }
 
     pub fn calculate_settlement_amount(ctx: &SettlementContext) -> Result<SettlementResult> {
@@ -51,6 +54,21 @@ pub mod perp_lp_pool_settlement {
         }
     }
 
+    pub fn validate_settlement_amount(
+        ctx: &SettlementContext,
+        result: &SettlementResult,
+    ) -> Result<()> {
+        if result.amount_transferred > ctx.max_settle_quote_amount as u64 {
+            msg!(
+                "Amount to settle exceeds maximum allowed, {} > {}",
+                result.amount_transferred,
+                ctx.max_settle_quote_amount
+            );
+            return Err(ErrorCode::LpPoolSettleInvariantBreached.into());
+        }
+        Ok(())
+    }
+
     fn calculate_lp_to_perp_settlement(ctx: &SettlementContext) -> Result<SettlementResult> {
         if ctx.quote_constituent_token_balance == 0 {
             return Ok(SettlementResult {
@@ -61,12 +79,11 @@ pub mod perp_lp_pool_settlement {
             });
         }
 
-        let amount_to_send = if ctx.quote_owed_from_lp > ctx.quote_constituent_token_balance as i64
-        {
-            ctx.quote_constituent_token_balance
-        } else {
-            ctx.quote_owed_from_lp as u64
-        };
+        let amount_to_send = ctx
+            .quote_owed_from_lp
+            .cast::<u64>()?
+            .min(ctx.quote_constituent_token_balance)
+            .min(ctx.max_settle_quote_amount);
 
         Ok(SettlementResult {
             amount_transferred: amount_to_send,
@@ -77,7 +94,7 @@ pub mod perp_lp_pool_settlement {
     }
 
     fn calculate_perp_to_lp_settlement(ctx: &SettlementContext) -> Result<SettlementResult> {
-        let amount_to_send = ctx.quote_owed_from_lp.abs() as u64;
+        let amount_to_send = (ctx.quote_owed_from_lp.abs() as u64).min(ctx.max_settle_quote_amount);
 
         if ctx.fee_pool_balance >= amount_to_send as u128 {
             // Fee pool can cover entire amount
@@ -133,7 +150,7 @@ pub mod perp_lp_pool_settlement {
         match result.direction {
             SettlementDirection::FromLpPool => {
                 controller::spot_balance::update_spot_balances(
-                    (result.amount_transferred as u128),
+                    result.amount_transferred as u128,
                     &SpotBalanceType::Deposit,
                     quote_spot_market,
                     &mut perp_market.amm.fee_pool,

programs/drift/src/state/lp_pool.rs

@@ -738,7 +738,7 @@ impl LPPool {
         msg!("Aum before quote owed from lp pool: {}", aum);
 
         for cache_datum in amm_cache.iter() {
-            aum -= cache_datum.quote_owed_from_lp_pool as i128;
+            aum = aum.saturating_sub(cache_datum.quote_owed_from_lp_pool as i128);
         }
 
         let aum_u128 = aum.max(0i128).cast::<u128>()?;
@@ -944,35 +944,6 @@ impl Constituent {
             .safe_div(token_precision)
     }
 
-    /// Returns the fee to charge for a swap to/from this constituent
-    /// The fee is a linear interpolation between the swap_fee_min and swap_fee_max based on the post-swap deviation from the target weight
-    /// precision: PERCENTAGE_PRECISION
-    pub fn get_fee_to_charge(&self, post_swap_weight: i64, target_weight: i64) -> DriftResult<i64> {
-        let min_weight = target_weight.safe_sub(self.max_weight_deviation as i64)?;
-        let max_weight = target_weight.safe_add(self.max_weight_deviation as i64)?;
-        let (slope_numerator, slope_denominator) = if post_swap_weight > target_weight {
-            let num = self.swap_fee_max.safe_sub(self.swap_fee_min)?;
-            let denom = max_weight.safe_sub(target_weight)?;
-            (num, denom)
-        } else {
-            let num = self.swap_fee_min.safe_sub(self.swap_fee_max)?;
-            let denom = target_weight.safe_sub(min_weight)?;
-            (num, denom)
-        };
-        if slope_denominator == 0 {
-            return Ok(self.swap_fee_min);
-        }
-        let b = self
-            .swap_fee_min
-            .safe_mul(slope_denominator)?
-            .safe_sub(target_weight.safe_mul(slope_numerator)?)?;
-        Ok(post_swap_weight
-            .safe_mul(slope_numerator)?
-            .safe_add(b)?
-            .safe_div(slope_denominator)?
-            .clamp(self.swap_fee_min, self.swap_fee_max))
-    }
-
     pub fn sync_token_balance(&mut self, token_account_amount: u64) {
         self.token_balance = token_account_amount;
     }
@@ -1249,9 +1220,11 @@ impl<'a> AccountZeroCopyMut<'a, TargetsDatum, ConstituentTargetBaseFixed> {
                     .safe_mul(*price as i128)?
                     .safe_div(BASE_PRECISION_I128)?;
 
-                target_notional += notional
-                    .saturating_mul(weight as i128)
-                    .saturating_div(PERCENTAGE_PRECISION_I128);
+                target_notional = target_notional.saturating_add(
+                    notional
+                        .saturating_mul(weight as i128)
+                        .saturating_div(PERCENTAGE_PRECISION_I128),
+                );
             }
 
             let cell = self.get_mut(i as u32);
@@ -1550,7 +1523,7 @@ pub fn update_constituent_target_base_for_derivatives(
             aum,
             WeightValidationFlags::NONE,
         )?;
-        let mut derivative_weights_sum = 0;
+        let mut derivative_weights_sum: u64 = 0;
         for constituent_index in constituent_indexes {
             let constituent = constituent_map.get_ref(constituent_index)?;
             if constituent.last_oracle_price
@@ -1572,11 +1545,12 @@ pub fn update_constituent_target_base_for_derivatives(
                 continue;
             }
 
-            derivative_weights_sum += constituent.derivative_weight;
+            derivative_weights_sum =
+                derivative_weights_sum.saturating_add(constituent.derivative_weight);
 
-            let target_weight = target_parent_weight
-                .safe_mul(constituent.derivative_weight as i64)?
-                .safe_div(PERCENTAGE_PRECISION_I64)?;
+            let target_weight = (target_parent_weight as i128)
+                .safe_mul(constituent.derivative_weight.cast::<i128>()?)?
+                .safe_div(PERCENTAGE_PRECISION_I128)?;
 
             msg!(
                 "constituent: {}, target weight: {}",
@@ -1585,7 +1559,7 @@ pub fn update_constituent_target_base_for_derivatives(
             );
             let target_base = aum
                 .cast::<i128>()?
-                .safe_mul(target_weight as i128)?
+                .safe_mul(target_weight)?
                 .safe_div(PERCENTAGE_PRECISION_I128)?
                 .safe_mul(10_i128.pow(constituent.decimals as u32))?
                 .safe_div(constituent.last_oracle_price as i128)?;