Nour/parameterize dlp (#1731)

* add validates and test for withdraw limit

* settlement  max

* update idl

* merge conflicts

Author: moosecat2

programs/drift/src/instructions/admin.rs

@@ -4711,6 +4711,7 @@ pub fn handle_initialize_lp_pool(
     max_mint_fee: i64,
     revenue_rebalance_period: u64,
     max_aum: u128,
+    max_settle_quote_amount_per_market: u64,
 ) -> Result<()> {
     let mut lp_pool = ctx.accounts.lp_pool.load_init()?;
     let mint = ctx.accounts.mint.key();
@@ -4724,11 +4725,11 @@ pub fn handle_initialize_lp_pool(
         last_aum: 0,
         last_aum_slot: 0,
         last_aum_ts: 0,
+        max_settle_quote_amount: max_settle_quote_amount_per_market,
         last_revenue_rebalance_ts: 0,
         total_fees_received: 0,
         total_fees_paid: 0,
         total_mint_redeem_fees_paid: 0,
-        oldest_oracle_slot: 0,
         bump: ctx.bumps.lp_pool,
         min_mint_fee,
         max_mint_fee_premium: max_mint_fee,
@@ -5016,6 +5017,7 @@ pub fn handle_initialize_constituent<'info>(
     max_weight_deviation: i64,
     swap_fee_min: i64,
     swap_fee_max: i64,
+    max_borrow_token_amount: u64,
     oracle_staleness_threshold: u64,
     cost_to_trade_bps: i32,
     constituent_derivative_index: Option<i16>,
@@ -5067,6 +5069,7 @@ pub fn handle_initialize_constituent<'info>(
     constituent.mint = ctx.accounts.spot_market_mint.key();
     constituent.token_vault = ctx.accounts.constituent_vault.key();
     constituent.bump = ctx.bumps.constituent;
+    constituent.max_borrow_token_amount = max_borrow_token_amount;
     constituent.lp_pool = lp_pool.pubkey;
     constituent.constituent_index = (constituent_target_base.targets.len() - 1) as u16;
     constituent.next_swap_id = 1;
@@ -5101,6 +5104,7 @@ pub struct ConstituentParams {
     pub max_weight_deviation: Option<i64>,
     pub swap_fee_min: Option<i64>,
     pub swap_fee_max: Option<i64>,
+    pub max_borrow_token_amount: Option<u64>,
     pub oracle_staleness_threshold: Option<u64>,
     pub cost_to_trade_bps: Option<i32>,
     pub constituent_derivative_index: Option<i16>,
@@ -5211,6 +5215,38 @@ pub fn handle_update_constituent_params<'info>(
         constituent.xi = constituent_params.xi.unwrap();
     }
 
+    if let Some(max_borrow_token_amount) = constituent_params.max_borrow_token_amount {
+        msg!(
+            "max_borrow_token_amount: {:?} -> {:?}",
+            constituent.max_borrow_token_amount,
+            max_borrow_token_amount
+        );
+        constituent.max_borrow_token_amount = max_borrow_token_amount;
+    }
+
+    Ok(())
+}
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Default)]
+pub struct LpPoolParams {
+    pub max_settle_quote_amount: Option<u64>,
+}
+
+pub fn handle_update_lp_pool_params<'info>(
+    ctx: Context<UpdateLpPoolParams>,
+    lp_pool_params: LpPoolParams,
+) -> Result<()> {
+    let mut lp_pool = ctx.accounts.lp_pool.load_mut()?;
+
+    if let Some(max_settle_quote_amount) = lp_pool_params.max_settle_quote_amount {
+        msg!(
+            "max_settle_quote_amount: {:?} -> {:?}",
+            lp_pool.max_settle_quote_amount,
+            max_settle_quote_amount
+        );
+        lp_pool.max_settle_quote_amount = max_settle_quote_amount;
+    }
+
     Ok(())
 }
 
@@ -6683,6 +6719,18 @@ pub struct UpdateConstituentParams<'info> {
     pub constituent: AccountLoader<'info, Constituent>,
 }
 
+#[derive(Accounts)]
+pub struct UpdateLpPoolParams<'info> {
+    #[account(mut)]
+    pub lp_pool: AccountLoader<'info, LPPool>,
+    #[account(
+        mut,
+        constraint = admin.key() == admin_hot_wallet::id() || admin.key() == state.admin
+    )]
+    pub admin: Signer<'info>,
+    pub state: Box<Account<'info, State>>,
+}
+
 #[derive(AnchorSerialize, AnchorDeserialize, Clone, Default)]
 pub struct AddAmmConstituentMappingDatum {
     pub constituent_index: u16,

programs/drift/src/instructions/keeper.rs

@@ -3046,7 +3046,14 @@ pub fn handle_settle_perp_to_lp_pool<'c: 'info, 'info>(
         };
 
         // Calculate settlement
-        let settlement_result = calculate_settlement_amount(&settlement_ctx)?;
+        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);
+        }
 
         if settlement_result.direction == SettlementDirection::None {
             continue;

programs/drift/src/instructions/lp_pool.rs

@@ -16,6 +16,7 @@ use crate::{
         constants::{PERCENTAGE_PRECISION_I64, PRICE_PRECISION},
         oracle::{is_oracle_valid_for_action, oracle_validity, DriftAction},
         safe_math::SafeMath,
+        spot_balance,
     },
     math_error, msg, safe_decrement, safe_increment,
     state::{
@@ -246,7 +247,7 @@ pub fn handle_update_lp_pool_aum<'c: 'info, 'info>(
         ErrorCode::InvalidPDA,
         "Amm cache PDA does not match expected PDA"
     )?;
-
+  
     let (aum, crypto_delta, derivative_groups) = lp_pool.update_aum(
         now,
         slot,
@@ -958,6 +959,9 @@ pub fn handle_deposit_to_program_vault<'c: 'info, 'info>(
         Some(ctx.accounts.state.oracle_guard_rails),
     )?;
 
+    constituent.sync_token_balance(ctx.accounts.constituent_token_account.amount);
+    let balance_before = constituent.get_full_balance(&spot_market)?;
+
     if amount == 0 {
         return Err(ErrorCode::InsufficientDeposit.into());
     }
@@ -1000,6 +1004,8 @@ pub fn handle_deposit_to_program_vault<'c: 'info, 'info>(
     safe_increment!(spot_position.cumulative_deposits, amount.cast()?);
 
     ctx.accounts.spot_market_vault.reload()?;
+    ctx.accounts.constituent_token_account.reload()?;
+    constituent.sync_token_balance(ctx.accounts.constituent_token_account.amount);
     spot_market.validate_max_token_deposits_and_borrows(false)?;
 
     validate!(
@@ -1008,6 +1014,15 @@ pub fn handle_deposit_to_program_vault<'c: 'info, 'info>(
         "Spot market vault amount mismatch after deposit"
     )?;
 
+    validate!(
+        constituent
+            .get_full_balance(&spot_market)?
+            .abs_diff(balance_before)
+            <= 1,
+        ErrorCode::LpInvariantFailed,
+        "Constituent balance mismatch after desposit to program vault"
+    )?;
+
     Ok(())
 }
 
@@ -1028,6 +1043,10 @@ pub fn handle_withdraw_from_program_vault<'c: 'info, 'info>(
         Some(ctx.accounts.state.oracle_guard_rails),
     )?;
 
+    constituent.sync_token_balance(ctx.accounts.constituent_token_account.amount);
+
+    let balance_before = constituent.get_full_balance(&spot_market)?;
+
     if amount == 0 {
         return Err(ErrorCode::InsufficientDeposit.into());
     }
@@ -1045,35 +1064,65 @@ pub fn handle_withdraw_from_program_vault<'c: 'info, 'info>(
         clock.unix_timestamp,
     )?;
 
+    // Can only borrow up to the max
+    let token_amount = constituent.spot_balance.get_token_amount(&spot_market)?;
+    let amount_to_transfer = if constituent.spot_balance.balance_type == SpotBalanceType::Borrow {
+        amount.min(
+            constituent
+                .max_borrow_token_amount
+                .safe_sub(token_amount as u64)?,
+        )
+    } else {
+        amount.min(
+            constituent
+                .max_borrow_token_amount
+                .safe_add(token_amount as u64)?,
+        )
+    };
+
     controller::token::send_from_program_vault(
         &ctx.accounts.token_program,
         &spot_market_vault,
         &ctx.accounts.constituent_token_account,
         &ctx.accounts.drift_signer,
         state.signer_nonce,
-        amount,
+        amount_to_transfer,
         &Some(*ctx.accounts.mint.clone()),
     )?;
+    ctx.accounts.constituent_token_account.reload()?;
+    constituent.sync_token_balance(ctx.accounts.constituent_token_account.amount);
 
     // Adjust BLPosition for the new deposits
     let spot_position = &mut constituent.spot_balance;
     update_spot_balances(
-        amount as u128,
+        amount_to_transfer as u128,
         &SpotBalanceType::Borrow,
         &mut spot_market,
         spot_position,
         true,
     )?;
 
-    safe_decrement!(spot_position.cumulative_deposits, amount.cast()?);
+    safe_decrement!(
+        spot_position.cumulative_deposits,
+        amount_to_transfer.cast()?
+    );
 
     ctx.accounts.spot_market_vault.reload()?;
+    spot_market.validate_max_token_deposits_and_borrows(true)?;
+
     math::spot_withdraw::validate_spot_market_vault_amount(
         &spot_market,
         ctx.accounts.spot_market_vault.amount,
     )?;
 
-    spot_market.validate_max_token_deposits_and_borrows(true)?;
+    validate!(
+        constituent
+            .get_full_balance(&spot_market)?
+            .abs_diff(balance_before)
+            <= 1,
+        ErrorCode::LpInvariantFailed,
+        "Constituent balance mismatch after withdraw from program vault"
+    )?;
 
     Ok(())
 }

programs/drift/src/lib.rs

@@ -1759,6 +1759,7 @@ pub mod drift {
         max_mint_fee: i64,
         revenue_rebalance_period: u64,
         max_aum: u128,
+        max_settle_quote_amount_per_market: u64,
     ) -> Result<()> {
         handle_initialize_lp_pool(
             ctx,
@@ -1767,6 +1768,7 @@ pub mod drift {
             max_mint_fee,
             revenue_rebalance_period,
             max_aum,
+            max_settle_quote_amount_per_market,
         )
     }
 
@@ -1824,6 +1826,7 @@ pub mod drift {
         max_weight_deviation: i64,
         swap_fee_min: i64,
         swap_fee_max: i64,
+        max_borrow_token_amount: u64,
         oracle_staleness_threshold: u64,
         cost_to_trade: i32,
         constituent_derivative_index: Option<i16>,
@@ -1842,6 +1845,7 @@ pub mod drift {
             max_weight_deviation,
             swap_fee_min,
             swap_fee_max,
+            max_borrow_token_amount,
             oracle_staleness_threshold,
             cost_to_trade,
             constituent_derivative_index,
@@ -1862,6 +1866,13 @@ pub mod drift {
         handle_update_constituent_params(ctx, constituent_params)
     }
 
+    pub fn update_lp_pool_params(
+        ctx: Context<UpdateLpPoolParams>,
+        lp_pool_params: LpPoolParams,
+    ) -> Result<()> {
+        handle_update_lp_pool_params(ctx, lp_pool_params)
+    }
+
     pub fn add_amm_constituent_mapping_data(
         ctx: Context<AddAmmConstituentMappingData>,
         amm_constituent_mapping_data: Vec<AddAmmConstituentMappingDatum>,

programs/drift/src/state/constituent_map.rs

@@ -133,7 +133,7 @@ impl<'a> ConstituentMap<'a> {
             )?;
 
             // constituent index 276 bytes from front of account
-            let constituent_index = u16::from_le_bytes(*array_ref![data, 284, 2]);
+            let constituent_index = u16::from_le_bytes(*array_ref![data, 292, 2]);
             if constituent_map.0.contains_key(&constituent_index) {
                 msg!(
                     "Can not include same constituent index twice {}",

programs/drift/src/state/lp_pool.rs

@@ -76,7 +76,7 @@ pub struct LPPool {
     pub last_aum_ts: i64, // 8, 160
 
     /// Oldest slot of constituent oracles
-    pub oldest_oracle_slot: u64,
+    pub max_settle_quote_amount: u64,
 
     /// timestamp of last vAMM revenue rebalance
     pub last_revenue_rebalance_ts: u64, // 8, 168
@@ -731,7 +731,6 @@ impl LPPool {
         }
         aum = aum_i128.max(0i128).cast::<u128>()?;
 
-        self.oldest_oracle_slot = oldest_slot;
         self.last_aum = aum;
         self.last_aum_slot = slot;
         self.last_aum_ts = now;
@@ -819,6 +818,10 @@ pub struct Constituent {
     /// precision: PERCENTAGE_PRECISION
     pub swap_fee_max: i64,
 
+    /// Max Borrow amount:
+    /// precision: token precision
+    pub max_borrow_token_amount: u64,
+
     /// ata token balance in token precision
     pub token_balance: u64,
 
@@ -859,7 +862,7 @@ pub struct Constituent {
 }
 
 impl Size for Constituent {
-    const SIZE: usize = 296;
+    const SIZE: usize = 304;
 }
 
 impl Constituent {