program: isolation position init

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

@@ -2197,7 +2197,7 @@ pub mod liquidate_perp {
         .unwrap();
 
         let market_after = perp_market_map.get_ref(&0).unwrap();
-        assert!(!user.is_being_liquidated());
+        assert!(!user.is_cross_margin_being_liquidated());
         assert_eq!(market_after.amm.total_liquidation_fee, 41787043);
     }
 
@@ -2351,7 +2351,7 @@ pub mod liquidate_perp {
         .unwrap();
 
         // user out of liq territory
-        assert!(!user.is_being_liquidated());
+        assert!(!user.is_cross_margin_being_liquidated());
 
         let oracle_price = oracle_map
             .get_price_data(&(oracle_price_key, OracleSource::Pyth))
@@ -4256,7 +4256,7 @@ pub mod liquidate_spot {
         .unwrap();
 
         assert_eq!(user.last_active_slot, 1);
-        assert_eq!(user.is_being_liquidated(), true);
+        assert_eq!(user.is_cross_margin_being_liquidated(), true);
         assert_eq!(user.liquidation_margin_freed, 7000031);
         assert_eq!(user.spot_positions[0].scaled_balance, 990558159000);
         assert_eq!(user.spot_positions[1].scaled_balance, 9406768999);
@@ -4326,7 +4326,7 @@ pub mod liquidate_spot {
         let pct_margin_freed = (user.liquidation_margin_freed as u128) * PRICE_PRECISION
             / (margin_shortage + user.liquidation_margin_freed as u128);
         assert_eq!(pct_margin_freed, 433267); // ~43.3%
-        assert_eq!(user.is_being_liquidated(), true);
+        assert_eq!(user.is_cross_margin_being_liquidated(), true);
 
         let slot = 136_u64;
         liquidate_spot(
@@ -4353,7 +4353,7 @@ pub mod liquidate_spot {
         assert_eq!(user.liquidation_margin_freed, 0);
         assert_eq!(user.spot_positions[0].scaled_balance, 455580082000);
         assert_eq!(user.spot_positions[1].scaled_balance, 4067681997);
-        assert_eq!(user.is_being_liquidated(), false);
+        assert_eq!(user.is_cross_margin_being_liquidated(), false);
     }
 
     #[test]
@@ -6873,7 +6873,7 @@ pub mod liquidate_perp_pnl_for_deposit {
         )
         .unwrap();
 
-        let margin_shortage = calc.margin_shortage().unwrap();
+        let margin_shortage = calc.cross_margin_margin_shortage().unwrap();
 
         let pct_margin_freed = (user.liquidation_margin_freed as u128) * PRICE_PRECISION
             / (margin_shortage + user.liquidation_margin_freed as u128);
@@ -6914,7 +6914,7 @@ pub mod liquidate_perp_pnl_for_deposit {
         )
         .unwrap();
 
-        let margin_shortage = calc.margin_shortage().unwrap();
+        let margin_shortage = calc.cross_margin_margin_shortage().unwrap();
 
         let pct_margin_freed = (user.liquidation_margin_freed as u128) * PRICE_PRECISION
             / (margin_shortage + user.liquidation_margin_freed as u128);
@@ -8560,7 +8560,7 @@ pub mod liquidate_spot_with_swap {
         )
         .unwrap();
 
-        assert_eq!(user.is_being_liquidated(), false);
+        assert_eq!(user.is_cross_margin_being_liquidated(), false);
 
         let quote_spot_market = spot_market_map.get_ref(&0).unwrap();
         let sol_spot_market = spot_market_map.get_ref(&1).unwrap();

programs/drift/src/controller/orders.rs

@@ -118,7 +118,7 @@ pub fn place_perp_order(
         )?;
     }
 
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
 
     if params.is_update_high_leverage_mode() {
         if let Some(config) = high_leverage_mode_config {
@@ -519,8 +519,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 +536,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 {
@@ -1024,7 +1028,7 @@ pub fn fill_perp_order(
         "Order must be triggered first"
     )?;
 
-    if user.is_bankrupt() {
+    if user.is_cross_margin_bankrupt() {
         msg!("user is bankrupt");
         return Ok((0, 0));
     }
@@ -1475,7 +1479,7 @@ fn get_maker_orders_info(
 
         let mut maker = load_mut!(user_account_loader)?;
 
-        if maker.is_being_liquidated() || maker.is_bankrupt() {
+        if maker.is_being_liquidated() {
             continue;
         }
 
@@ -1941,16 +1945,23 @@ fn fulfill_perp_order(
         )?;
 
         if !taker_margin_calculation.meets_margin_requirement() {
+            let (margin_requirement, total_collateral) = if taker_margin_calculation.has_isolated_position_margin_calculation(market_index) {
+                let isolated_position_margin_calculation = taker_margin_calculation.get_isolated_position_margin_calculation(market_index)?;
+                (isolated_position_margin_calculation.margin_requirement, isolated_position_margin_calculation.total_collateral)
+            } else {
+                (taker_margin_calculation.margin_requirement, taker_margin_calculation.total_collateral)
+            };
+
             msg!(
                 "taker breached fill requirements (margin requirement {}) (total_collateral {})",
-                taker_margin_calculation.margin_requirement,
-                taker_margin_calculation.total_collateral
+                margin_requirement,
+                total_collateral
             );
             return Err(ErrorCode::InsufficientCollateral);
         }
     }
 
-    for (maker_key, maker_base_asset_amount_filled) in maker_fills {
+    for (maker_key, (maker_base_asset_amount_filled)) in maker_fills {
         let mut maker = makers_and_referrer.get_ref_mut(&maker_key)?;
 
         let maker_stats = if maker.authority == user.authority {
@@ -2001,11 +2012,18 @@ fn fulfill_perp_order(
         }
 
         if !maker_margin_calculation.meets_margin_requirement() {
+            let (margin_requirement, total_collateral) = if maker_margin_calculation.has_isolated_position_margin_calculation(market_index) {
+                let isolated_position_margin_calculation = maker_margin_calculation.get_isolated_position_margin_calculation(market_index)?;
+                (isolated_position_margin_calculation.margin_requirement, isolated_position_margin_calculation.total_collateral)
+            } else {
+                (maker_margin_calculation.margin_requirement, maker_margin_calculation.total_collateral)
+            };
+
             msg!(
                 "maker ({}) breached fill requirements (margin requirement {}) (total_collateral {})",
                 maker_key,
-                maker_margin_calculation.margin_requirement,
-                maker_margin_calculation.total_collateral
+                margin_requirement,
+                total_collateral
             );
             return Err(ErrorCode::InsufficientCollateral);
         }
@@ -2949,7 +2967,7 @@ pub fn trigger_order(
         state.liquidation_margin_buffer_ratio,
     )?;
 
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
 
     let mut perp_market = perp_market_map.get_ref_mut(&market_index)?;
     let (oracle_price_data, oracle_validity) = oracle_map.get_price_data_and_validity(
@@ -3167,7 +3185,7 @@ pub fn force_cancel_orders(
         ErrorCode::UserIsBeingLiquidated
     )?;
 
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
 
     let margin_calc = calculate_margin_requirement_and_total_collateral_and_liability_info(
         user,
@@ -3184,6 +3202,8 @@ pub fn force_cancel_orders(
         ErrorCode::SufficientCollateral
     )?;
 
+    let cross_margin_meets_initial_margin_requirement = margin_calc.cross_margin_meets_margin_requirement();
+
     let mut total_fee = 0_u64;
 
     for order_index in 0..user.orders.len() {
@@ -3210,6 +3230,10 @@ pub fn force_cancel_orders(
                     continue;
                 }
 
+                if cross_margin_meets_initial_margin_requirement {
+                    continue;
+                }
+
                 state.spot_fee_structure.flat_filler_fee
             }
             MarketType::Perp => {
@@ -3224,6 +3248,17 @@ pub fn force_cancel_orders(
                     continue;
                 }
 
+                if !user.get_perp_position(market_index)?.is_isolated() {
+                    if cross_margin_meets_initial_margin_requirement {
+                        continue;
+                    }
+                } else {
+                    let isolated_position_meets_margin_requirement = margin_calc.isolated_position_meets_margin_requirement(market_index)?;
+                    if isolated_position_meets_margin_requirement {
+                        continue;
+                    }
+                }
+
                 state.perp_fee_structure.flat_filler_fee
             }
         };
@@ -3361,7 +3396,7 @@ pub fn place_spot_order(
         state.liquidation_margin_buffer_ratio,
     )?;
 
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
 
     if options.try_expire_orders {
         expire_orders(
@@ -3691,7 +3726,7 @@ pub fn fill_spot_order(
         "Order must be triggered first"
     )?;
 
-    if user.is_bankrupt() {
+    if user.is_cross_margin_bankrupt() {
         msg!("User is bankrupt");
         return Ok(0);
     }
@@ -3999,7 +4034,7 @@ fn get_spot_maker_orders_info(
 
         let mut maker = load_mut!(user_account_loader)?;
 
-        if maker.is_being_liquidated() || maker.is_bankrupt() {
+        if maker.is_being_liquidated() {
             continue;
         }
 
@@ -5184,7 +5219,7 @@ pub fn trigger_spot_order(
         state.liquidation_margin_buffer_ratio,
     )?;
 
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
 
     let spot_market = spot_market_map.get_ref(&market_index)?;
     let (oracle_price_data, oracle_validity) = oracle_map.get_price_data_and_validity(

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;
@@ -61,7 +59,7 @@ pub fn settle_pnl(
     meets_margin_requirement: Option<bool>,
     mode: SettlePnlMode,
 ) -> DriftResult {
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
     let now = clock.unix_timestamp;
     {
         let spot_market = &mut spot_market_map.get_quote_spot_market_mut()?;
@@ -268,17 +266,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],
@@ -322,7 +346,7 @@ pub fn settle_expired_position(
     clock: &Clock,
     state: &State,
 ) -> DriftResult {
-    validate!(!user.is_bankrupt(), ErrorCode::UserBankrupt)?;
+    validate!(!user.is_cross_margin_bankrupt(), ErrorCode::UserBankrupt)?;
 
     // 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)?)
@@ -359,6 +383,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) {