program: scale down init asset weights past threshold

programs/drift/src/instructions/admin.rs

@@ -267,7 +267,8 @@ pub fn handle_initialize_spot_market(
         flash_loan_amount: 0,
         flash_loan_initial_token_amount: 0,
         total_swap_fee: 0,
-        padding: [0; 56],
+        scale_initial_asset_weight_start: 0,
+        padding: [0; 48],
         insurance_fund: InsuranceFund {
             vault: *ctx.accounts.insurance_fund_vault.to_account_info().key,
             unstaking_period: THIRTEEN_DAY,

programs/drift/src/math/margin.rs

@@ -397,6 +397,7 @@ pub fn calculate_margin_requirement_and_total_collateral_and_liability_info(
                             spot_market
                                 .get_asset_weight(
                                     worst_case_token_amount.unsigned_abs(),
+                                    oracle_price_data.price,
                                     &margin_requirement_type,
                                 )?
                                 .cast()?,

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

@@ -16,6 +16,10 @@ mod test {
     use crate::state::perp_market::{ContractTier, PerpMarket, AMM};
     use crate::state::spot_market::{AssetTier, SpotMarket};
     use crate::state::user::PerpPosition;
+    use crate::{
+        PRICE_PRECISION_I64, QUOTE_PRECISION_U64, SPOT_BALANCE_PRECISION,
+        SPOT_CUMULATIVE_INTEREST_PRECISION,
+    };
 
     #[test]
     fn asset_tier_checks() {
@@ -80,8 +84,9 @@ mod test {
         };
 
         let size = 1000 * QUOTE_PRECISION;
+        let price = QUOTE_PRECISION_I64;
         let asset_weight = spot_market
-            .get_asset_weight(size, &MarginRequirementType::Initial)
+            .get_asset_weight(size, price, &MarginRequirementType::Initial)
             .unwrap();
         assert_eq!(asset_weight, 9000);
 
@@ -92,7 +97,7 @@ mod test {
 
         spot_market.imf_factor = 10;
         let asset_weight = spot_market
-            .get_asset_weight(size, &MarginRequirementType::Initial)
+            .get_asset_weight(size, price, &MarginRequirementType::Initial)
             .unwrap();
         assert_eq!(asset_weight, 9000);
 
@@ -103,13 +108,13 @@ mod test {
 
         let same_asset_weight_diff_imf_factor = 8357;
         let asset_weight = spot_market
-            .get_asset_weight(size * 1_000_000, &MarginRequirementType::Initial)
+            .get_asset_weight(size * 1_000_000, price, &MarginRequirementType::Initial)
             .unwrap();
         assert_eq!(asset_weight, same_asset_weight_diff_imf_factor);
 
         spot_market.imf_factor = 10000;
         let asset_weight = spot_market
-            .get_asset_weight(size, &MarginRequirementType::Initial)
+            .get_asset_weight(size, price, &MarginRequirementType::Initial)
             .unwrap();
         assert_eq!(asset_weight, same_asset_weight_diff_imf_factor);
 
@@ -120,7 +125,7 @@ mod test {
 
         spot_market.imf_factor = SPOT_IMF_PRECISION / 10;
         let asset_weight = spot_market
-            .get_asset_weight(size, &MarginRequirementType::Initial)
+            .get_asset_weight(size, price, &MarginRequirementType::Initial)
             .unwrap();
         assert_eq!(asset_weight, 2642);
 
@@ -135,6 +140,49 @@ mod test {
         assert_eq!(maint_lib_weight, 31622);
     }
 
+    #[test]
+    fn spot_market_scale_initial_asset_weight() {
+        let mut sol_spot_market = SpotMarket {
+            initial_asset_weight: 9000,
+            initial_liability_weight: 11000,
+            decimals: 9,
+            imf_factor: 0,
+            scale_initial_asset_weight_start: 500_000 * QUOTE_PRECISION_U64,
+            cumulative_deposit_interest: SPOT_CUMULATIVE_INTEREST_PRECISION,
+            ..SpotMarket::default()
+        };
+
+        let price = 25 * PRICE_PRECISION_I64;
+
+        sol_spot_market.deposit_balance = SPOT_BALANCE_PRECISION;
+        let asset_weight = sol_spot_market
+            .get_scaled_initial_asset_weight(price)
+            .unwrap();
+
+        assert_eq!(asset_weight, 9000);
+
+        sol_spot_market.deposit_balance = 20000 * SPOT_BALANCE_PRECISION;
+        let asset_weight = sol_spot_market
+            .get_scaled_initial_asset_weight(price)
+            .unwrap();
+
+        assert_eq!(asset_weight, 9000);
+
+        sol_spot_market.deposit_balance = 40000 * SPOT_BALANCE_PRECISION;
+        let asset_weight = sol_spot_market
+            .get_scaled_initial_asset_weight(price)
+            .unwrap();
+
+        assert_eq!(asset_weight, 4500);
+
+        sol_spot_market.deposit_balance = 60000 * SPOT_BALANCE_PRECISION;
+        let asset_weight = sol_spot_market
+            .get_scaled_initial_asset_weight(price)
+            .unwrap();
+
+        assert_eq!(asset_weight, 3000);
+    }
+
     #[test]
     fn calculate_user_equity_value_tests() {
         let mut market = PerpMarket {

programs/drift/src/math/orders.rs

@@ -1059,6 +1059,7 @@ pub fn calculate_max_spot_order_size(
 
         let asset_weight = spot_market.get_asset_weight(
             worst_case_token_amount.unsigned_abs(),
+            oracle_price_data.price,
             &MarginRequirementType::Initial,
         )?;
 
@@ -1075,6 +1076,7 @@ pub fn calculate_max_spot_order_size(
     } else if worst_case_token_amount > 0 && direction == PositionDirection::Short {
         let asset_weight = spot_market.get_asset_weight(
             worst_case_token_amount.unsigned_abs(),
+            oracle_price_data.price,
             &MarginRequirementType::Initial,
         )?;
 
@@ -1132,6 +1134,7 @@ pub fn calculate_max_spot_order_size(
     let free_collateral_delta = calculate_free_collateral_delta_for_spot(
         &spot_market,
         worst_case_token_amount.unsigned_abs(),
+        oracle_price_data.price,
         direction,
     )?;
 
@@ -1153,6 +1156,7 @@ pub fn calculate_max_spot_order_size(
         worst_case_token_amount
             .unsigned_abs()
             .safe_add(order_size.cast()?)?,
+        oracle_price_data.price,
         direction,
     )?;
 
@@ -1176,13 +1180,15 @@ pub fn calculate_max_spot_order_size(
 fn calculate_free_collateral_delta_for_spot(
     spot_market: &SpotMarket,
     worst_case_token_amount: u128,
+    oracle_price: i64,
     order_direction: PositionDirection,
 ) -> DriftResult<u32> {
     Ok(if order_direction == PositionDirection::Long {
-        SPOT_WEIGHT_PRECISION.sub(
-            spot_market
-                .get_asset_weight(worst_case_token_amount, &MarginRequirementType::Initial)?,
-        )
+        SPOT_WEIGHT_PRECISION.sub(spot_market.get_asset_weight(
+            worst_case_token_amount,
+            oracle_price,
+            &MarginRequirementType::Initial,
+        )?)
     } else {
         spot_market
             .get_liability_weight(worst_case_token_amount, &MarginRequirementType::Initial)?

programs/drift/src/math/spot_swap.rs

@@ -40,6 +40,7 @@ pub fn select_margin_type_for_swap(
             let weight = if token_amount >= 0 {
                 market.get_asset_weight(
                     token_amount.unsigned_abs(),
+                    price,
                     &MarginRequirementType::Initial,
                 )?
             } else {

programs/drift/src/state/spot_market.rs

@@ -14,7 +14,7 @@ use crate::math::margin::{
     MarginRequirementType,
 };
 use crate::math::safe_math::SafeMath;
-use crate::math::spot_balance::{calculate_utilization, get_token_amount};
+use crate::math::spot_balance::{calculate_utilization, get_token_amount, get_token_value};
 
 use crate::state::oracle::{HistoricalIndexData, HistoricalOracleData, OracleSource};
 use crate::state::perp_market::{MarketStatus, PoolBalance};
@@ -167,7 +167,9 @@ pub struct SpotMarket {
     /// The total fees received from swaps
     /// precision: token mint precision
     pub total_swap_fee: u64,
-    pub padding: [u8; 56],
+    /// When to begin scaling down the initial asset weight
+    pub scale_initial_asset_weight_start: u64,
+    pub padding: [u8; 48],
 }
 
 impl Default for SpotMarket {
@@ -224,7 +226,8 @@ impl Default for SpotMarket {
             flash_loan_amount: 0,
             flash_loan_initial_token_amount: 0,
             total_swap_fee: 0,
-            padding: [0; 56],
+            scale_initial_asset_weight_start: 0,
+            padding: [0; 48],
         }
     }
 }
@@ -274,6 +277,7 @@ impl SpotMarket {
     pub fn get_asset_weight(
         &self,
         size: u128,
+        oracle_price: i64,
         margin_requirement_type: &MarginRequirementType,
     ) -> DriftResult<u32> {
         let size_precision = 10_u128.pow(self.decimals);
@@ -286,7 +290,7 @@ impl SpotMarket {
 
         let default_asset_weight = match margin_requirement_type {
             MarginRequirementType::Initial | MarginRequirementType::Fill => {
-                self.initial_asset_weight
+                self.get_scaled_initial_asset_weight(oracle_price)?
             }
             MarginRequirementType::Maintenance => self.maintenance_asset_weight,
         };
@@ -302,6 +306,30 @@ impl SpotMarket {
         Ok(asset_weight)
     }
 
+    pub fn get_scaled_initial_asset_weight(&self, oracle_price: i64) -> DriftResult<u32> {
+        if self.scale_initial_asset_weight_start == 0 {
+            return Ok(self.initial_asset_weight);
+        }
+
+        let deposits = self.get_deposits()?;
+        let deposit_value =
+            get_token_value(deposits.cast()?, self.decimals, oracle_price)?.cast::<u128>()?;
+
+        let scale_initial_asset_weight_start =
+            self.scale_initial_asset_weight_start.cast::<u128>()?;
+        let asset_weight = if deposit_value < scale_initial_asset_weight_start {
+            self.initial_asset_weight
+        } else {
+            self.initial_asset_weight
+                .cast::<u128>()?
+                .safe_mul(scale_initial_asset_weight_start)?
+                .safe_div(deposit_value)?
+                .cast::<u32>()?
+        };
+
+        Ok(asset_weight)
+    }
+
     pub fn get_liability_weight(
         &self,
         size: u128,

sdk/src/math/spotBalance.ts

@@ -152,6 +152,7 @@ export function getTokenValue(
 
 export function calculateAssetWeight(
 	balanceAmount: BN,
+	oraclePrice: BN,
 	spotMarket: SpotMarketAccount,
 	marginCategory: MarginCategory
 ): BN {
@@ -174,7 +175,7 @@ export function calculateAssetWeight(
 			assetWeight = calculateSizeDiscountAssetWeight(
 				sizeInAmmReservePrecision,
 				new BN(spotMarket.imfFactor),
-				new BN(spotMarket.initialAssetWeight)
+				calculateScaledInitialAssetWeight(spotMarket, oraclePrice)
 			);
 			break;
 		case 'Maintenance':
@@ -185,13 +186,35 @@ export function calculateAssetWeight(
 			);
 			break;
 		default:
-			assetWeight = new BN(spotMarket.initialAssetWeight);
+			assetWeight = calculateScaledInitialAssetWeight(spotMarket, oraclePrice);
 			break;
 	}
 
 	return assetWeight;
 }
 
+export function calculateScaledInitialAssetWeight(
+	spotMarket: SpotMarketAccount,
+	oraclePrice: BN,
+) : BN {
+	if (spotMarket.scaleInitialAssetWeightStart.eq(ZERO)) {
+		return new BN(spotMarket.initialAssetWeight);
+	}
+
+	const deposits = getTokenAmount(
+		spotMarket.depositBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	const depositsValue = getTokenValue(deposits, spotMarket.decimals, oraclePrice);
+
+	if (depositsValue.lt(spotMarket.scaleInitialAssetWeightStart)) {
+		return new BN(spotMarket.initialAssetWeight);
+	} else {
+		return new BN(spotMarket.initialAssetWeight).mul(spotMarket.scaleInitialAssetWeightStart).div(depositsValue);
+	}
+}
+
 export function calculateLiabilityWeight(
 	size: BN,
 	spotMarket: SpotMarketAccount,

sdk/src/math/spotMarket.ts

@@ -21,12 +21,13 @@ export function castNumberToSpotPrecision(
 
 export function calculateSpotMarketMarginRatio(
 	market: SpotMarketAccount,
+	oraclePrice: BN,
 	marginCategory: MarginCategory,
 	size: BN,
 	balanceType: SpotBalanceType
 ): number {
 	if (isVariant(balanceType, 'deposit')) {
-		const assetWeight = calculateAssetWeight(size, market, marginCategory);
+		const assetWeight = calculateAssetWeight(size, oraclePrice, market, marginCategory);
 		return MARGIN_PRECISION.sub(assetWeight).toNumber();
 	} else {
 		const liabilityWeight = calculateLiabilityWeight(

sdk/src/types.ts

@@ -652,6 +652,7 @@ export type SpotMarketAccount = {
 	maintenanceLiabilityWeight: number;
 	liquidatorFee: number;
 	imfFactor: number;
+	scaleInitialAssetWeightStart: BN;
 
 	withdrawGuardThreshold: BN;
 	depositTokenTwap: BN;

sdk/src/user.ts

@@ -1098,6 +1098,7 @@ export class User {
 		if (marginCategory !== undefined) {
 			const weight = calculateAssetWeight(
 				tokenAmount,
+				oraclePriceData.price,
 				spotMarketAccount,
 				marginCategory
 			);
@@ -2052,6 +2053,7 @@ export class User {
 		if (signedTokenAmount.gt(ZERO)) {
 			const assetWeight = calculateAssetWeight(
 				signedTokenAmount,
+				this.driftClient.getOraclePriceDataAndSlot(market.oracle).data.price,
 				market,
 				'Maintenance'
 			);
@@ -2228,6 +2230,7 @@ export class User {
 		currentSpotMarketNetValue?: BN
 	): BN {
 		const market = this.driftClient.getSpotMarketAccount(targetMarketIndex);
+		const oraclePrice = this.driftClient.getOraclePriceDataAndSlot(market.oracle).data.price;
 
 		currentQuoteAssetValue = this.getSpotMarketAssetValue(
 			QUOTE_SPOT_MARKET_INDEX
@@ -2239,6 +2242,7 @@ export class User {
 		let freeCollateral = this.getFreeCollateral();
 		const marginRatio = calculateSpotMarketMarginRatio(
 			market,
+			oraclePrice,
 			'Initial',
 			ZERO,
 			isVariant(direction, 'long')
@@ -2253,6 +2257,7 @@ export class User {
 				tradeAmount = currentSpotMarketNetValue.abs();
 				const marginRatio = calculateSpotMarketMarginRatio(
 					market,
+					oraclePrice,
 					'Initial',
 					this.getTokenAmount(targetMarketIndex).abs(),
 					SpotBalanceType.BORROW
@@ -2267,6 +2272,7 @@ export class User {
 				tradeAmount = currentSpotMarketNetValue;
 				const marginRatio = calculateSpotMarketMarginRatio(
 					market,
+					oraclePrice,
 					'Initial',
 					this.getTokenAmount(targetMarketIndex),
 					SpotBalanceType.DEPOSIT