program: isolation position init

programs/drift/src/controller/orders.rs

@@ -115,6 +115,7 @@ pub fn place_perp_order(
             spot_market_map,
             oracle_map,
             state.liquidation_margin_buffer_ratio,
+            Some(params.market_index),
         )?;
     }
 
@@ -356,14 +357,21 @@ pub fn place_perp_order(
 
     options.update_risk_increasing(risk_increasing);
 
+    let isolated_position_market_index = if user.perp_positions[position_index].is_isolated() {
+        Some(market_index)
+    } else {
+        None
+    };
+
     // when orders are placed in bulk, only need to check margin on last place
-    if options.enforce_margin_check && !options.is_liquidation() {
+    if (options.enforce_margin_check || isolated_position_market_index.is_some()) && !options.is_liquidation() {
         meets_place_order_margin_requirement(
             user,
             perp_market_map,
             spot_market_map,
             oracle_map,
             options.risk_increasing,
+            isolated_position_market_index,
         )?;
     }
 
@@ -519,8 +527,10 @@ pub fn cancel_orders(
     market_type: Option<MarketType>,
     market_index: Option<u16>,
     direction: Option<PositionDirection>,
+    skip_isolated_positions: bool,
 ) -> DriftResult<Vec<u32>> {
     let mut canceled_order_ids: Vec<u32> = vec![];
+    let isolated_position_market_indexes = user.perp_positions.iter().filter(|position| position.is_isolated()).map(|position| position.market_index).collect::<Vec<u16>>();
     for order_index in 0..user.orders.len() {
         if user.orders[order_index].status != OrderStatus::Open {
             continue;
@@ -534,6 +544,8 @@ pub fn cancel_orders(
             if user.orders[order_index].market_index != market_index {
                 continue;
             }
+        } else if skip_isolated_positions && isolated_position_market_indexes.contains(&user.orders[order_index].market_index) {
+            continue;
         }
 
         if let Some(direction) = direction {
@@ -1036,6 +1048,7 @@ pub fn fill_perp_order(
             spot_market_map,
             oracle_map,
             state.liquidation_margin_buffer_ratio,
+            Some(market_index),
         ) {
             Ok(_) => {}
             Err(_) => {
@@ -1726,6 +1739,8 @@ fn fulfill_perp_order(
     let user_order_position_decreasing =
         determine_if_user_order_is_position_decreasing(user, market_index, user_order_index)?;
 
+    let user_is_isolated_position = user.get_perp_position(market_index)?.is_isolated();
+
     let perp_market = perp_market_map.get_ref(&market_index)?;
     let limit_price = fill_mode.get_limit_price(
         &user.orders[user_order_index],
@@ -1761,7 +1776,7 @@ fn fulfill_perp_order(
 
     let mut base_asset_amount = 0_u64;
     let mut quote_asset_amount = 0_u64;
-    let mut maker_fills: BTreeMap<Pubkey, i64> = BTreeMap::new();
+    let mut maker_fills: BTreeMap<Pubkey, (i64, bool)> = BTreeMap::new();
     let maker_direction = user.orders[user_order_index].direction.opposite();
     for fulfillment_method in fulfillment_methods.iter() {
         if user.orders[user_order_index].status != OrderStatus::Open {
@@ -1838,6 +1853,8 @@ fn fulfill_perp_order(
                     Some(&maker),
                 )?;
 
+                let maker_is_isolated_position = maker.get_perp_position(market_index)?.is_isolated();
+
                 let (fill_base_asset_amount, fill_quote_asset_amount, maker_fill_base_asset_amount) =
                     fulfill_perp_order_with_match(
                         market.deref_mut(),
@@ -1871,6 +1888,7 @@ fn fulfill_perp_order(
                         maker_key,
                         maker_direction,
                         maker_fill_base_asset_amount,
+                        maker_is_isolated_position,
                     )?;
                 }
 
@@ -1893,7 +1911,7 @@ fn fulfill_perp_order(
         quote_asset_amount
     )?;
 
-    let total_maker_fill = maker_fills.values().sum::<i64>();
+    let total_maker_fill = maker_fills.values().map(|(fill, _)| fill).sum::<i64>();
 
     validate!(
         total_maker_fill.unsigned_abs() <= base_asset_amount,
@@ -1923,6 +1941,10 @@ fn fulfill_perp_order(
             context = context.margin_ratio_override(MARGIN_PRECISION);
         }
 
+        if user_is_isolated_position {
+            context = context.isolated_position_market_index(market_index);
+        }
+
         let taker_margin_calculation =
             calculate_margin_requirement_and_total_collateral_and_liability_info(
                 user,
@@ -1950,7 +1972,7 @@ fn fulfill_perp_order(
         }
     }
 
-    for (maker_key, maker_base_asset_amount_filled) in maker_fills {
+    for (maker_key, (maker_base_asset_amount_filled, maker_is_isolated_position)) in maker_fills {
         let mut maker = makers_and_referrer.get_ref_mut(&maker_key)?;
 
         let maker_stats = if maker.authority == user.authority {
@@ -1981,6 +2003,10 @@ fn fulfill_perp_order(
             }
         }
 
+        if maker_is_isolated_position {
+            context = context.isolated_position_market_index(market_index);
+        }
+
         let maker_margin_calculation =
             calculate_margin_requirement_and_total_collateral_and_liability_info(
                 &maker,
@@ -2049,20 +2075,21 @@ fn get_referrer<'a>(
 
 #[inline(always)]
 fn update_maker_fills_map(
-    map: &mut BTreeMap<Pubkey, i64>,
+    map: &mut BTreeMap<Pubkey, (i64, bool)>,
     maker_key: &Pubkey,
     maker_direction: PositionDirection,
     fill: u64,
+    is_isolated_position: bool,
 ) -> DriftResult {
     let signed_fill = match maker_direction {
         PositionDirection::Long => fill.cast::<i64>()?,
         PositionDirection::Short => -fill.cast::<i64>()?,
     };
 
-    if let Some(maker_filled) = map.get_mut(maker_key) {
+    if let Some((maker_filled, _)) = map.get_mut(maker_key) {
         *maker_filled = maker_filled.safe_add(signed_fill)?;
     } else {
-        map.insert(*maker_key, signed_fill);
+        map.insert(*maker_key, (signed_fill, is_isolated_position));
     }
 
     Ok(())
@@ -2947,6 +2974,7 @@ pub fn trigger_order(
         spot_market_map,
         oracle_map,
         state.liquidation_margin_buffer_ratio,
+        Some(market_index),
     )?;
 
     validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
@@ -3072,8 +3100,14 @@ pub fn trigger_order(
 
     // If order increases risk and user is below initial margin, cancel it
     if is_risk_increasing && !user.orders[order_index].reduce_only {
+        let isolated_position_market_index = if user.get_perp_position(market_index)?.is_isolated() {
+            Some(market_index)
+        } else {
+            None
+        };
+
         let meets_initial_margin_requirement =
-            meets_initial_margin_requirement(user, perp_market_map, spot_market_map, oracle_map)?;
+            meets_initial_margin_requirement(user, perp_market_map, spot_market_map, oracle_map, isolated_position_market_index)?;
 
         if !meets_initial_margin_requirement {
             cancel_order(
@@ -3224,6 +3258,11 @@ pub fn force_cancel_orders(
                     continue;
                 }
 
+                // TODO: handle force deleting these orders
+                if user.get_perp_position(market_index)?.is_isolated() {
+                    continue;
+                }
+
                 state.perp_fee_structure.flat_filler_fee
             }
         };
@@ -3359,6 +3398,7 @@ pub fn place_spot_order(
         spot_market_map,
         oracle_map,
         state.liquidation_margin_buffer_ratio,
+        None,
     )?;
 
     validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
@@ -3571,6 +3611,7 @@ pub fn place_spot_order(
             spot_market_map,
             oracle_map,
             options.risk_increasing,
+            None,
         )?;
     }
 
@@ -3702,6 +3743,7 @@ pub fn fill_spot_order(
         spot_market_map,
         oracle_map,
         state.liquidation_margin_buffer_ratio,
+        None,
     ) {
         Ok(_) => {}
         Err(_) => {
@@ -4218,7 +4260,7 @@ fn fulfill_spot_order(
 
     let mut base_asset_amount = 0_u64;
     let mut quote_asset_amount = 0_u64;
-    let mut maker_fills: BTreeMap<Pubkey, i64> = BTreeMap::new();
+    let mut maker_fills: BTreeMap<Pubkey, (i64, bool)> = BTreeMap::new();
     let maker_direction = user.orders[user_order_index].direction.opposite();
     for fulfillment_method in fulfillment_methods.iter() {
         if user.orders[user_order_index].status != OrderStatus::Open {
@@ -4260,6 +4302,7 @@ fn fulfill_spot_order(
                         maker_key,
                         maker_direction,
                         base_filled,
+                        false,
                     )?;
                 }
 
@@ -5182,6 +5225,7 @@ pub fn trigger_spot_order(
         spot_market_map,
         oracle_map,
         state.liquidation_margin_buffer_ratio,
+        None,
     )?;
 
     validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
@@ -5331,7 +5375,7 @@ pub fn trigger_spot_order(
     // If order is risk increasing and user is below initial margin, cancel it
     if is_risk_increasing && !user.orders[order_index].reduce_only {
         let meets_initial_margin_requirement =
-            meets_initial_margin_requirement(user, perp_market_map, spot_market_map, oracle_map)?;
+            meets_initial_margin_requirement(user, perp_market_map, spot_market_map, oracle_map, None)?;
 
         if !meets_initial_margin_requirement {
             cancel_order(

programs/drift/src/controller/pnl.rs

@@ -17,9 +17,7 @@ use crate::math::oracle::{is_oracle_valid_for_action, DriftAction};
 
 use crate::math::casting::Cast;
 use crate::math::margin::{
-    calculate_margin_requirement_and_total_collateral_and_liability_info,
     meets_maintenance_margin_requirement, meets_settle_pnl_maintenance_margin_requirement,
-    MarginRequirementType,
 };
 use crate::math::position::calculate_base_asset_value_with_expiry_price;
 use crate::math::safe_math::SafeMath;
@@ -83,14 +81,18 @@ pub fn settle_pnl(
 
     // cannot settle negative pnl this way on a user who is in liquidation territory
     if unrealized_pnl < 0 {
+        let isolated_position_market_index = user.perp_positions[position_index].is_isolated().then_some(market_index);
+
         // may already be cached
         let meets_margin_requirement = match meets_margin_requirement {
-            Some(meets_margin_requirement) => meets_margin_requirement,
-            None => meets_settle_pnl_maintenance_margin_requirement(
+            Some(meets_margin_requirement) if !isolated_position_market_index.is_some() => meets_margin_requirement,
+            // TODO check margin for isolate position
+            _ => meets_settle_pnl_maintenance_margin_requirement(
                 user,
                 perp_market_map,
                 spot_market_map,
                 oracle_map,
+                isolated_position_market_index,
             )?,
         };
 
@@ -268,17 +270,43 @@ pub fn settle_pnl(
         );
     }
 
-    update_spot_balances(
-        pnl_to_settle_with_user.unsigned_abs(),
-        if pnl_to_settle_with_user > 0 {
-            &SpotBalanceType::Deposit
-        } else {
-            &SpotBalanceType::Borrow
-        },
-        spot_market,
-        user.get_quote_spot_position_mut(),
-        false,
-    )?;
+    if user.perp_positions[position_index].is_isolated() {
+        let perp_position = &mut user.perp_positions[position_index];
+        if pnl_to_settle_with_user < 0 {
+            let token_amount = perp_position.get_isolated_position_token_amount(spot_market)?;
+
+            validate!(
+                token_amount >= pnl_to_settle_with_user.unsigned_abs(),
+                ErrorCode::InsufficientCollateralForSettlingPNL,
+                "user has insufficient deposit for market {}",
+                market_index
+            )?;
+        }
+
+        update_spot_balances(
+            pnl_to_settle_with_user.unsigned_abs(),
+            if pnl_to_settle_with_user > 0 {
+                &SpotBalanceType::Deposit
+            } else {
+                &SpotBalanceType::Borrow
+            },
+            spot_market,
+            perp_position,
+            false,
+        )?;
+    } else {
+        update_spot_balances(
+            pnl_to_settle_with_user.unsigned_abs(),
+            if pnl_to_settle_with_user > 0 {
+                &SpotBalanceType::Deposit
+            } else {
+                &SpotBalanceType::Borrow
+            },
+            spot_market,
+            user.get_quote_spot_position_mut(),
+            false,
+        )?;
+    }
 
     update_quote_asset_amount(
         &mut user.perp_positions[position_index],
@@ -324,8 +352,14 @@ pub fn settle_expired_position(
 ) -> DriftResult {
     validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
 
+    let isolated_position_market_index = if user.get_perp_position(perp_market_index)?.is_isolated() {
+        Some(perp_market_index)
+    } else {
+        None
+    };
+
     // cannot settle pnl this way on a user who is in liquidation territory
-    if !(meets_maintenance_margin_requirement(user, perp_market_map, spot_market_map, oracle_map)?)
+    if !(meets_maintenance_margin_requirement(user, perp_market_map, spot_market_map, oracle_map, isolated_position_market_index)?)
     {
         return Err(ErrorCode::InsufficientCollateralForSettlingPNL);
     }
@@ -359,6 +393,7 @@ pub fn settle_expired_position(
         Some(MarketType::Perp),
         Some(perp_market_index),
         None,
+        true,
     )?;
 
     let position_index = match get_position_index(&user.perp_positions, perp_market_index) {

programs/drift/src/controller/pnl/tests.rs

@@ -400,7 +400,7 @@ pub fn user_does_not_meet_strict_maintenance_requirement() {
     assert_eq!(result, Err(ErrorCode::InsufficientCollateralForSettlingPNL));
 
     let meets_maintenance =
-        meets_maintenance_margin_requirement(&user, &market_map, &spot_market_map, &mut oracle_map)
+        meets_maintenance_margin_requirement(&user, &market_map, &spot_market_map, &mut oracle_map, None)
             .unwrap();
 
     assert_eq!(meets_maintenance, true);
@@ -410,6 +410,7 @@ pub fn user_does_not_meet_strict_maintenance_requirement() {
         &market_map,
         &spot_market_map,
         &mut oracle_map,
+        None,
     )
     .unwrap();
 

programs/drift/src/error.rs

@@ -193,8 +193,8 @@ pub enum ErrorCode {
     SpotMarketInsufficientDeposits,
     #[msg("UserMustSettleTheirOwnPositiveUnsettledPNL")]
     UserMustSettleTheirOwnPositiveUnsettledPNL,
-    #[msg("CantUpdatePoolBalanceType")]
-    CantUpdatePoolBalanceType,
+    #[msg("CantUpdateSpotBalanceType")]
+    CantUpdateSpotBalanceType,
     #[msg("InsufficientCollateralForSettlingPNL")]
     InsufficientCollateralForSettlingPNL,
     #[msg("AMMNotUpdatedInSameSlot")]
@@ -639,6 +639,8 @@ pub enum ErrorCode {
     InvalidIfRebalanceConfig,
     #[msg("Invalid If Rebalance Swap")]
     InvalidIfRebalanceSwap,
+    #[msg("Invalid Isolated Perp Market")]
+    InvalidIsolatedPerpMarket,
 }
 
 #[macro_export]