add more max perp size tests

Author: 0xbigz

programs/drift/src/math/orders/tests.rs

@@ -1956,7 +1956,7 @@ mod calculate_max_perp_order_size {
     use crate::state::perp_market_map::PerpMarketMap;
     use crate::state::spot_market::{SpotBalanceType, SpotMarket};
     use crate::state::spot_market_map::SpotMarketMap;
-    use crate::state::user::{Order, PerpPosition, SpotPosition, User};
+    use crate::state::user::{MarginMode, Order, PerpPosition, SpotPosition, User, UserStatus};
     use crate::test_utils::get_pyth_price;
     use crate::test_utils::*;
     use crate::{
@@ -3160,6 +3160,192 @@ mod calculate_max_perp_order_size {
         assert!(total_collateral.unsigned_abs() - margin_requirement < 100 * QUOTE_PRECISION);
     }
 
+    #[test]
+    pub fn sol_perp_hlm_with_imf() {
+        let slot = 0_u64;
+
+        let mut oracle_price = get_pyth_price(100, 6);
+        let oracle_price_key =
+            Pubkey::from_str("J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix").unwrap();
+        let pyth_program = crate::ids::pyth_program::id();
+        create_account_info!(
+            oracle_price,
+            &oracle_price_key,
+            &pyth_program,
+            oracle_account_info
+        );
+        let mut oracle_map = OracleMap::load_one(&oracle_account_info, slot, None).unwrap();
+
+        let mut market = PerpMarket {
+            amm: AMM {
+                base_asset_reserve: 100 * AMM_RESERVE_PRECISION,
+                quote_asset_reserve: 100 * AMM_RESERVE_PRECISION,
+                bid_base_asset_reserve: 100 * AMM_RESERVE_PRECISION,
+                bid_quote_asset_reserve: 100 * AMM_RESERVE_PRECISION,
+                ask_base_asset_reserve: 100 * AMM_RESERVE_PRECISION,
+                ask_quote_asset_reserve: 100 * AMM_RESERVE_PRECISION,
+                sqrt_k: 100 * AMM_RESERVE_PRECISION,
+                peg_multiplier: 100 * PEG_PRECISION,
+                max_slippage_ratio: 50,
+                max_fill_reserve_fraction: 100,
+                order_step_size: 1000,
+                order_tick_size: 1,
+                oracle: oracle_price_key,
+                base_spread: 0, // 1 basis point
+                historical_oracle_data: HistoricalOracleData {
+                    last_oracle_price: (100 * PRICE_PRECISION) as i64,
+                    last_oracle_price_twap: (100 * PRICE_PRECISION) as i64,
+                    last_oracle_price_twap_5min: (100 * PRICE_PRECISION) as i64,
+
+                    ..HistoricalOracleData::default()
+                },
+                ..AMM::default()
+            },
+            margin_ratio_initial: 1000,
+            margin_ratio_maintenance: 500,
+            high_leverage_margin_ratio_initial: 100,
+            high_leverage_margin_ratio_maintenance: 66,
+            imf_factor: 50,
+            status: MarketStatus::Active,
+            ..PerpMarket::default_test()
+        };
+        market.amm.max_base_asset_reserve = u128::MAX;
+        market.amm.min_base_asset_reserve = 0;
+
+        create_anchor_account_info!(market, PerpMarket, market_account_info);
+        let market_map = PerpMarketMap::load_one(&market_account_info, true).unwrap();
+
+        let mut usdc_spot_market = SpotMarket {
+            market_index: 0,
+            oracle_source: OracleSource::QuoteAsset,
+            cumulative_deposit_interest: SPOT_CUMULATIVE_INTEREST_PRECISION,
+            decimals: 6,
+            initial_asset_weight: SPOT_WEIGHT_PRECISION,
+            maintenance_asset_weight: SPOT_WEIGHT_PRECISION,
+            deposit_balance: 10000 * SPOT_BALANCE_PRECISION,
+            liquidator_fee: 0,
+            historical_oracle_data: HistoricalOracleData {
+                last_oracle_price_twap: PRICE_PRECISION_I64,
+                last_oracle_price_twap_5min: PRICE_PRECISION_I64,
+                ..HistoricalOracleData::default()
+            },
+            ..SpotMarket::default()
+        };
+        create_anchor_account_info!(usdc_spot_market, SpotMarket, usdc_spot_market_account_info);
+        let spot_market_account_infos = Vec::from([&usdc_spot_market_account_info]);
+        let spot_market_map =
+            SpotMarketMap::load_multiple(spot_market_account_infos, true).unwrap();
+
+        let mut spot_positions = [SpotPosition::default(); 8];
+        spot_positions[0] = SpotPosition {
+            market_index: 0,
+            balance_type: SpotBalanceType::Deposit,
+            scaled_balance: 10000 * SPOT_BALANCE_PRECISION_U64,
+            ..SpotPosition::default()
+        };
+        let mut user = User {
+            orders: [Order::default(); 32],
+            perp_positions: get_positions(PerpPosition {
+                market_index: 0,
+                ..PerpPosition::default()
+            }),
+            spot_positions,
+            margin_mode: MarginMode::HighLeverage,
+            ..User::default()
+        };
+
+        let max_order_size = calculate_max_perp_order_size(
+            &user,
+            0,
+            0,
+            PositionDirection::Short,
+            &market_map,
+            &spot_market_map,
+            &mut oracle_map,
+        )
+        .unwrap();
+        assert_eq!(max_order_size, 4098356557000); // 4098
+
+        let mut spot_positions = [SpotPosition::default(); 8];
+        spot_positions[0] = SpotPosition {
+            market_index: 0,
+            balance_type: SpotBalanceType::Deposit,
+            scaled_balance: 100 * SPOT_BALANCE_PRECISION_U64,
+            ..SpotPosition::default()
+        };
+        let mut user = User {
+            orders: [Order::default(); 32],
+            perp_positions: get_positions(PerpPosition {
+                market_index: 0,
+                ..PerpPosition::default()
+            }),
+            spot_positions,
+            margin_mode: MarginMode::HighLeverage,
+            ..User::default()
+        };
+
+        let max_order_size = calculate_max_perp_order_size(
+            &user,
+            0,
+            0,
+            PositionDirection::Short,
+            &market_map,
+            &spot_market_map,
+            &mut oracle_map,
+        )
+        .unwrap();
+        assert_eq!(max_order_size, 84737288000); // 84
+
+
+        let mut spot_positions = [SpotPosition::default(); 8];
+        spot_positions[0] = SpotPosition {
+            market_index: 0,
+            balance_type: SpotBalanceType::Deposit,
+            scaled_balance: 10 * SPOT_BALANCE_PRECISION_U64,
+            ..SpotPosition::default()
+        };
+        let mut user = User {
+            orders: [Order::default(); 32],
+            perp_positions: get_positions(PerpPosition {
+                market_index: 0,
+                ..PerpPosition::default()
+            }),
+            spot_positions,
+            margin_mode: MarginMode::HighLeverage,
+            ..User::default()
+        };
+
+        let max_order_size = calculate_max_perp_order_size(
+            &user,
+            0,
+            0,
+            PositionDirection::Short,
+            &market_map,
+            &spot_market_map,
+            &mut oracle_map,
+        )
+        .unwrap();
+        assert_eq!(max_order_size, 9605769000); // 9.6
+
+        user.perp_positions[0].open_orders = 1;
+        user.perp_positions[0].open_asks = -(max_order_size as i64);
+
+        let MarginCalculation {
+            margin_requirement,
+            total_collateral,
+            ..
+        } = calculate_margin_requirement_and_total_collateral_and_liability_info(
+            &user,
+            &market_map,
+            &spot_market_map,
+            &mut oracle_map,
+            MarginContext::standard(MarginRequirementType::Initial).strict(true),
+        )
+        .unwrap();
+
+        assert!(total_collateral.unsigned_abs() - margin_requirement < QUOTE_PRECISION);
+    }
+
     #[test]
     pub fn swift_failure() {
         let clock_slot = 0_u64;

programs/drift/src/state/perp_market/tests.rs

@@ -172,6 +172,25 @@ mod get_margin_ratio {
             perp_market.high_leverage_margin_ratio_initial as u32
         );
 
+
+        let hlm_margin_ratio_initial = perp_market
+            .get_margin_ratio(BASE_PRECISION, MarginRequirementType::Initial, true)
+            .unwrap();
+
+        assert_eq!(
+            hlm_margin_ratio_initial,
+            perp_market.high_leverage_margin_ratio_initial as u32
+        );
+
+        let hlm_margin_ratio_initial = perp_market
+            .get_margin_ratio(BASE_PRECISION * 10, MarginRequirementType::Initial, true)
+            .unwrap();
+
+        assert_eq!(
+            hlm_margin_ratio_initial,
+            104 // slightly under 100x at 10 base
+        );
+
         let hlm_margin_ratio_initial_sized = perp_market
             .get_margin_ratio(BASE_PRECISION * 3000, MarginRequirementType::Initial, true)
             .unwrap();