@drift-labs/sdk 2.145.0 → 2.146.0-alpha.13

package/src/user.ts

@@ -68,6 +68,7 @@ import { getUser30dRollingVolumeEstimate } from './math/trade';
 import {
 	MarketType,
 	PositionDirection,
+	PositionFlag,
 	SpotBalanceType,
 	SpotMarketAccount,
 } from './types';
@@ -106,6 +107,9 @@ import { StrictOraclePrice } from './oracles/strictOraclePrice';
 
 import { calculateSpotFuelBonus, calculatePerpFuelBonus } from './math/fuel';
 import { grpcUserAccountSubscriber } from './accounts/grpcUserAccountSubscriber';
+import { MarginCalculation, MarginContext } from './marginCalculation';
+
+export type MarginType = 'Cross' | 'Isolated';
 
 export class User {
 	driftClient: DriftClient;
@@ -338,9 +342,27 @@ export class User {
 			lastQuoteAssetAmountPerLp: ZERO,
 			perLpBase: 0,
 			maxMarginRatio: 0,
+			positionFlag: 0,
+			isolatedPositionScaledBalance: ZERO,
 		};
 	}
 
+	public getIsolatePerpPositionTokenAmount(perpMarketIndex: number): BN {
+		const perpPosition = this.getPerpPosition(perpMarketIndex);
+		const perpMarket = this.driftClient.getPerpMarketAccount(perpMarketIndex);
+		const spotMarket = this.driftClient.getSpotMarketAccount(
+			perpMarket.quoteSpotMarketIndex
+		);
+		if (perpPosition === undefined) {
+			return ZERO;
+		}
+		return getTokenAmount(
+			perpPosition.isolatedPositionScaledBalance,
+			spotMarket,
+			SpotBalanceType.DEPOSIT
+		);
+	}
+
 	public getClonedPosition(position: PerpPosition): PerpPosition {
 		const clonedPosition = Object.assign({}, position);
 		return clonedPosition;
@@ -513,62 +535,113 @@ export class User {
 	 */
 	public getFreeCollateral(
 		marginCategory: MarginCategory = 'Initial',
-		enterHighLeverageMode = undefined
+		enterHighLeverageMode = false,
+		perpMarketIndex?: number
 	): BN {
-		const totalCollateral = this.getTotalCollateral(marginCategory, true);
-		const marginRequirement =
-			marginCategory === 'Initial'
-				? this.getInitialMarginRequirement(enterHighLeverageMode)
-				: this.getMaintenanceMarginRequirement();
-		const freeCollateral = totalCollateral.sub(marginRequirement);
-		return freeCollateral.gte(ZERO) ? freeCollateral : ZERO;
+		const marginCalc = this.getMarginCalculation(marginCategory, {
+			enteringHighLeverage: enterHighLeverageMode,
+		});
+
+		if (perpMarketIndex !== undefined) {
+			return marginCalc.getIsolatedFreeCollateral(perpMarketIndex);
+		} else {
+			return marginCalc.getCrossFreeCollateral();
+		}
 	}
 
 	/**
-	 * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+	 * @deprecated Use the overload that includes { marginType, perpMarketIndex }
 	 */
 	public getMarginRequirement(
 		marginCategory: MarginCategory,
 		liquidationBuffer?: BN,
-		strict = false,
-		includeOpenOrders = true,
-		enteringHighLeverage = undefined
+		strict?: boolean,
+		includeOpenOrders?: boolean,
+		enteringHighLeverage?: boolean
+	): BN;
+
+	/**
+	 * Calculates the margin requirement based on the specified parameters.
+	 *
+	 * @param marginCategory - The category of margin to calculate ('Initial' or 'Maintenance').
+	 * @param liquidationBuffer - Optional buffer amount to consider during liquidation scenarios.
+	 * @param strict - Optional flag to enforce strict margin calculations.
+	 * @param includeOpenOrders - Optional flag to include open orders in the margin calculation.
+	 * @param enteringHighLeverage - Optional flag indicating if the user is entering high leverage mode.
+	 * @param perpMarketIndex - Optional index of the perpetual market. Required if marginType is 'Isolated'.
+	 *
+	 * @returns The calculated margin requirement as a BN (BigNumber).
+	 */
+	public getMarginRequirement(
+		marginCategory: MarginCategory,
+		liquidationBuffer?: BN,
+		strict?: boolean,
+		includeOpenOrders?: boolean,
+		enteringHighLeverage?: boolean,
+		perpMarketIndex?: number
+	): BN;
+
+	public getMarginRequirement(
+		marginCategory: MarginCategory,
+		liquidationBuffer?: BN,
+		strict?: boolean,
+		includeOpenOrders?: boolean,
+		enteringHighLeverage?: boolean,
+		perpMarketIndex?: number
 	): BN {
-		return this.getTotalPerpPositionLiability(
-			marginCategory,
-			liquidationBuffer,
-			includeOpenOrders,
+		const marginCalc = this.getMarginCalculation(marginCategory, {
 			strict,
-			enteringHighLeverage
-		).add(
-			this.getSpotMarketLiabilityValue(
-				undefined,
-				marginCategory,
-				liquidationBuffer,
-				includeOpenOrders,
-				strict
-			)
-		);
+			includeOpenOrders,
+			enteringHighLeverage,
+			liquidationBuffer,
+		});
+
+		// If perpMarketIndex is provided, compute only for that market index
+		if (perpMarketIndex !== undefined) {
+			const isolatedMarginCalculation =
+				marginCalc.isolatedMarginCalculations.get(perpMarketIndex);
+			const { marginRequirement } = isolatedMarginCalculation;
+
+			return marginRequirement;
+		}
+
+		// Default: Cross margin requirement
+		// TODO: should we be using plus buffer sometimes?
+		return marginCalc.marginRequirement;
 	}
 
 	/**
 	 * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getInitialMarginRequirement(enterHighLeverageMode = undefined): BN {
+	public getInitialMarginRequirement(
+		enterHighLeverageMode = false,
+		perpMarketIndex?: number
+	): BN {
 		return this.getMarginRequirement(
 			'Initial',
 			undefined,
-			true,
+			false,
 			undefined,
-			enterHighLeverageMode
+			enterHighLeverageMode,
+			perpMarketIndex
 		);
 	}
 
 	/**
 	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN {
-		return this.getMarginRequirement('Maintenance', liquidationBuffer);
+	public getMaintenanceMarginRequirement(
+		liquidationBuffer?: BN,
+		perpMarketIndex?: number
+	): BN {
+		return this.getMarginRequirement(
+			'Maintenance',
+			liquidationBuffer,
+			true, // strict default
+			true, // includeOpenOrders default
+			false, // enteringHighLeverage default
+			perpMarketIndex
+		);
 	}
 
 	public getActivePerpPositionsForUserAccount(
@@ -578,7 +651,8 @@ export class User {
 			(pos) =>
 				!pos.baseAssetAmount.eq(ZERO) ||
 				!pos.quoteAssetAmount.eq(ZERO) ||
-				!(pos.openOrders == 0)
+				!(pos.openOrders == 0) ||
+				pos.isolatedPositionScaledBalance.gt(ZERO)
 		);
 	}
 
@@ -639,6 +713,7 @@ export class User {
 				const market = this.driftClient.getPerpMarketAccount(
 					perpPosition.marketIndex
 				);
+				if (!market) return unrealizedPnl;
 				const oraclePriceData = this.getMMOracleDataForPerpMarket(
 					market.marketIndex
 				);
@@ -1151,22 +1226,21 @@ export class User {
 		marginCategory: MarginCategory = 'Initial',
 		strict = false,
 		includeOpenOrders = true,
-		liquidationBuffer?: BN
+		liquidationBuffer?: BN,
+		perpMarketIndex?: number
 	): BN {
-		return this.getSpotMarketAssetValue(
-			undefined,
-			marginCategory,
+		const marginCalc = this.getMarginCalculation(marginCategory, {
+			strict,
 			includeOpenOrders,
-			strict
-		).add(
-			this.getUnrealizedPNL(
-				true,
-				undefined,
-				marginCategory,
-				strict,
-				liquidationBuffer
-			)
-		);
+			liquidationBuffer,
+		});
+
+		if (perpMarketIndex !== undefined) {
+			return marginCalc.isolatedMarginCalculations.get(perpMarketIndex)
+				.totalCollateral;
+		}
+
+		return marginCalc.totalCollateral;
 	}
 
 	public getLiquidationBuffer(): BN | undefined {
@@ -1184,13 +1258,26 @@ export class User {
 	 * calculates User Health by comparing total collateral and maint. margin requirement
 	 * @returns : number (value from [0, 100])
 	 */
-	public getHealth(): number {
-		if (this.isBeingLiquidated()) {
+	public getHealth(perpMarketIndex?: number): number {
+		const marginCalc = this.getMarginCalculation('Maintenance');
+		if (this.isCrossMarginBeingLiquidated(marginCalc) && !perpMarketIndex) {
 			return 0;
 		}
 
-		const totalCollateral = this.getTotalCollateral('Maintenance');
-		const maintenanceMarginReq = this.getMaintenanceMarginRequirement();
+		let totalCollateral: BN;
+		let maintenanceMarginReq: BN;
+
+		if (perpMarketIndex) {
+			const isolatedMarginCalc =
+				marginCalc.isolatedMarginCalculations.get(perpMarketIndex);
+			if (isolatedMarginCalc) {
+				totalCollateral = isolatedMarginCalc.totalCollateral;
+				maintenanceMarginReq = isolatedMarginCalc.marginRequirement;
+			}
+		} else {
+			totalCollateral = marginCalc.totalCollateral;
+			maintenanceMarginReq = marginCalc.marginRequirement;
+		}
 
 		let health: number;
 
@@ -1226,6 +1313,8 @@ export class User {
 			perpPosition.marketIndex
 		);
 
+		if (!market) return ZERO;
+
 		let valuationPrice = this.getOracleDataForPerpMarket(
 			market.marketIndex
 		).price;
@@ -1489,9 +1578,9 @@ export class User {
 	 * calculates current user leverage which is (total liability size) / (net asset value)
 	 * @returns : Precision TEN_THOUSAND
 	 */
-	public getLeverage(includeOpenOrders = true): BN {
+	public getLeverage(includeOpenOrders = true, perpMarketIndex?: number): BN {
 		return this.calculateLeverageFromComponents(
-			this.getLeverageComponents(includeOpenOrders)
+			this.getLeverageComponents(includeOpenOrders, undefined, perpMarketIndex)
 		);
 	}
 
@@ -1519,13 +1608,61 @@ export class User {
 
 	getLeverageComponents(
 		includeOpenOrders = true,
-		marginCategory: MarginCategory = undefined
+		marginCategory: MarginCategory = undefined,
+		perpMarketIndex?: number
 	): {
 		perpLiabilityValue: BN;
 		perpPnl: BN;
 		spotAssetValue: BN;
 		spotLiabilityValue: BN;
 	} {
+		if (perpMarketIndex) {
+			const perpPosition = this.getPerpPositionOrEmpty(perpMarketIndex);
+			const perpLiability = this.calculateWeightedPerpPositionLiability(
+				perpPosition,
+				marginCategory,
+				undefined,
+				includeOpenOrders
+			);
+			const perpMarket = this.driftClient.getPerpMarketAccount(
+				perpPosition.marketIndex
+			);
+
+			const oraclePriceData = this.getOracleDataForPerpMarket(
+				perpPosition.marketIndex
+			);
+			const quoteSpotMarket = this.driftClient.getSpotMarketAccount(
+				perpMarket.quoteSpotMarketIndex
+			);
+			const quoteOraclePriceData = this.getOracleDataForSpotMarket(
+				perpMarket.quoteSpotMarketIndex
+			);
+			const strictOracle = new StrictOraclePrice(
+				quoteOraclePriceData.price,
+				quoteOraclePriceData.twap
+			);
+
+			const positionUnrealizedPnl = calculatePositionPNL(
+				perpMarket,
+				perpPosition,
+				true,
+				oraclePriceData
+			);
+
+			const spotAssetValue = getStrictTokenValue(
+				perpPosition.isolatedPositionScaledBalance,
+				quoteSpotMarket.decimals,
+				strictOracle
+			);
+
+			return {
+				perpLiabilityValue: perpLiability,
+				perpPnl: positionUnrealizedPnl,
+				spotAssetValue,
+				spotLiabilityValue: ZERO,
+			};
+		}
+
 		const perpLiability = this.getTotalPerpPositionLiability(
 			marginCategory,
 			undefined,
@@ -1819,35 +1956,113 @@ export class User {
 		canBeLiquidated: boolean;
 		marginRequirement: BN;
 		totalCollateral: BN;
+		liquidationStatuses: Map<
+			'cross' | number,
+			{ canBeLiquidated: boolean; marginRequirement: BN; totalCollateral: BN }
+		>;
 	} {
-		const liquidationBuffer = this.getLiquidationBuffer();
+		// Deprecated signature retained for backward compatibility in type only
+		// but implementation now delegates to the new Map-based API and returns cross margin status.
+		const map = this.getLiquidationStatuses();
+		const cross = map.get('cross');
+		return cross
+			? { ...cross, liquidationStatuses: map }
+			: {
+					canBeLiquidated: false,
+					marginRequirement: ZERO,
+					totalCollateral: ZERO,
+					liquidationStatuses: map,
+			  };
+	}
 
-		const totalCollateral = this.getTotalCollateral(
-			'Maintenance',
-			undefined,
-			undefined,
-			liquidationBuffer
-		);
+	/**
+	 * New API: Returns liquidation status for cross and each isolated perp position.
+	 * Map keys:
+	 *  - 'cross' for cross margin
+	 *  - marketIndex (number) for each isolated perp position
+	 */
+	public getLiquidationStatuses(
+		marginCalc?: MarginCalculation
+	): Map<
+		'cross' | number,
+		{ canBeLiquidated: boolean; marginRequirement: BN; totalCollateral: BN }
+	> {
+		// If not provided, use buffer-aware calc for canBeLiquidated checks
+		if (!marginCalc) {
+			const liquidationBuffer = this.getLiquidationBuffer();
+			marginCalc = this.getMarginCalculation('Maintenance', {
+				liquidationBuffer,
+			});
+		}
 
-		const marginRequirement =
-			this.getMaintenanceMarginRequirement(liquidationBuffer);
-		const canBeLiquidated = totalCollateral.lt(marginRequirement);
+		const result = new Map<
+			'cross' | number,
+			{
+				canBeLiquidated: boolean;
+				marginRequirement: BN;
+				totalCollateral: BN;
+			}
+		>();
+
+		// Cross margin status
+		const crossTotalCollateral = marginCalc.totalCollateral;
+		const crossMarginRequirement = marginCalc.marginRequirement;
+		result.set('cross', {
+			canBeLiquidated: crossTotalCollateral.lt(crossMarginRequirement),
+			marginRequirement: crossMarginRequirement,
+			totalCollateral: crossTotalCollateral,
+		});
 
-		return {
-			canBeLiquidated,
-			marginRequirement,
-			totalCollateral,
-		};
+		// Isolated positions status
+		for (const [
+			marketIndex,
+			isoCalc,
+		] of marginCalc.isolatedMarginCalculations) {
+			const isoTotalCollateral = isoCalc.totalCollateral;
+			const isoMarginRequirement = isoCalc.marginRequirement;
+			result.set(marketIndex, {
+				canBeLiquidated: isoTotalCollateral.lt(isoMarginRequirement),
+				marginRequirement: isoMarginRequirement,
+				totalCollateral: isoTotalCollateral,
+			});
+		}
+
+		return result;
 	}
 
-	public isBeingLiquidated(): boolean {
-		return (
+	public isBeingLiquidated(marginCalc?: MarginCalculation): boolean {
+		// Consider on-chain flags OR computed margin status (cross or any isolated)
+		const hasOnChainFlag =
 			(this.getUserAccount().status &
 				(UserStatus.BEING_LIQUIDATED | UserStatus.BANKRUPT)) >
-			0
+			0;
+		const calc = marginCalc ?? this.getMarginCalculation('Maintenance');
+		return (
+			hasOnChainFlag ||
+			this.isCrossMarginBeingLiquidated(calc) ||
+			this.isIsolatedMarginBeingLiquidated(calc)
 		);
 	}
 
+	/** Returns true if cross margin is currently below maintenance requirement (no buffer). */
+	public isCrossMarginBeingLiquidated(marginCalc?: MarginCalculation): boolean {
+		const calc = marginCalc ?? this.getMarginCalculation('Maintenance');
+		return calc.totalCollateral.lt(calc.marginRequirement);
+	}
+
+	/** Returns true if any isolated perp position is currently below its maintenance requirement (no buffer). */
+	public isIsolatedMarginBeingLiquidated(
+		marginCalc?: MarginCalculation
+	): boolean {
+		const calc = marginCalc ?? this.getMarginCalculation('Maintenance');
+		for (const [, isoCalc] of calc.isolatedMarginCalculations) {
+			if (isoCalc.totalCollateral.lt(isoCalc.marginRequirement)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	public hasStatus(status: UserStatus): boolean {
 		return (this.getUserAccount().status & status) > 0;
 	}
@@ -2004,8 +2219,61 @@ export class User {
 		marginCategory: MarginCategory = 'Maintenance',
 		includeOpenOrders = false,
 		offsetCollateral = ZERO,
-		enteringHighLeverage = undefined
+		enteringHighLeverage = false,
+		marginType?: MarginType
 	): BN {
+		const market = this.driftClient.getPerpMarketAccount(marketIndex);
+
+		const oracle =
+			this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
+
+		const oraclePrice =
+			this.driftClient.getOracleDataForPerpMarket(marketIndex).price;
+
+		const currentPerpPosition = this.getPerpPositionOrEmpty(marketIndex);
+
+		if (marginType === 'Isolated') {
+			const marginCalculation = this.getMarginCalculation(marginCategory, {
+				strict: false,
+				includeOpenOrders,
+				enteringHighLeverage,
+			});
+			const isolatedMarginCalculation =
+				marginCalculation.isolatedMarginCalculations.get(marketIndex);
+			const { totalCollateral, marginRequirement } = isolatedMarginCalculation;
+
+			const freeCollateral = BN.max(
+				ZERO,
+				totalCollateral.sub(marginRequirement)
+			).add(offsetCollateral);
+
+			const freeCollateralDelta = this.calculateFreeCollateralDeltaForPerp(
+				market,
+				currentPerpPosition,
+				positionBaseSizeChange,
+				oraclePrice,
+				marginCategory,
+				includeOpenOrders,
+				enteringHighLeverage
+			);
+
+			if (freeCollateralDelta.eq(ZERO)) {
+				return new BN(-1);
+			}
+
+			const liqPriceDelta = freeCollateral
+				.mul(QUOTE_PRECISION)
+				.div(freeCollateralDelta);
+
+			const liqPrice = oraclePrice.sub(liqPriceDelta);
+
+			if (liqPrice.lt(ZERO)) {
+				return new BN(-1);
+			}
+
+			return liqPrice;
+		}
+
 		const totalCollateral = this.getTotalCollateral(
 			marginCategory,
 			false,
@@ -2023,15 +2291,6 @@ export class User {
 			totalCollateral.sub(marginRequirement)
 		).add(offsetCollateral);
 
-		const oracle =
-			this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
-
-		const oraclePrice =
-			this.driftClient.getOracleDataForPerpMarket(marketIndex).price;
-
-		const market = this.driftClient.getPerpMarketAccount(marketIndex);
-		const currentPerpPosition = this.getPerpPositionOrEmpty(marketIndex);
-
 		positionBaseSizeChange = standardizeBaseAssetAmount(
 			positionBaseSizeChange,
 			market.amm.orderStepSize
@@ -3913,4 +4172,287 @@ export class User {
 			activeSpotPositions: activeSpotMarkets,
 		};
 	}
+
+	/**
+	 * Compute a consolidated margin snapshot once, without caching.
+	 * Consumers can use this to avoid duplicating work across separate calls.
+	 */
+	// TODO: need another param to tell it give it back leverage compnents
+	// TODO: change get leverage functions need to pull the right values from
+	public getMarginCalculation(
+		marginCategory: MarginCategory = 'Initial',
+		opts?: {
+			strict?: boolean; // mirror StrictOraclePrice application
+			includeOpenOrders?: boolean;
+			enteringHighLeverage?: boolean;
+			liquidationBuffer?: BN; // margin_buffer analog for buffer mode
+			marginRatioOverride?: number; // mirrors context.margin_ratio_override
+		}
+	): MarginCalculation {
+		const strict = opts?.strict ?? false;
+		const enteringHighLeverage = opts?.enteringHighLeverage ?? false;
+		const includeOpenOrders = opts?.includeOpenOrders ?? true; // TODO: remove this ??
+		const marginBuffer = opts?.liquidationBuffer; // treat as MARGIN_BUFFER ratio if provided
+		const marginRatioOverride = opts?.marginRatioOverride;
+
+		// Equivalent to on-chain user_custom_margin_ratio
+		let userCustomMarginRatio =
+			marginCategory === 'Initial' ? this.getUserAccount().maxMarginRatio : 0;
+		if (marginRatioOverride !== undefined) {
+			userCustomMarginRatio = Math.max(
+				userCustomMarginRatio,
+				marginRatioOverride
+			);
+		}
+
+		// Initialize calc via JS mirror of Rust MarginCalculation
+		const ctx = MarginContext.standard(marginCategory)
+			.strictMode(strict)
+			.setMarginBuffer(marginBuffer)
+			.setMarginRatioOverride(userCustomMarginRatio);
+		const calc = new MarginCalculation(ctx);
+
+		// SPOT POSITIONS
+		// TODO: include open orders in the worst-case simulation in the same way on both spot and perp positions
+		for (const spotPosition of this.getUserAccount().spotPositions) {
+			if (isSpotPositionAvailable(spotPosition)) continue;
+
+			const spotMarket = this.driftClient.getSpotMarketAccount(
+				spotPosition.marketIndex
+			);
+			const oraclePriceData = this.getOracleDataForSpotMarket(
+				spotPosition.marketIndex
+			);
+			const twap5 = strict
+				? calculateLiveOracleTwap(
+						spotMarket.historicalOracleData,
+						oraclePriceData,
+						new BN(Math.floor(Date.now() / 1000)),
+						FIVE_MINUTE
+				  )
+				: undefined;
+			const strictOracle = new StrictOraclePrice(oraclePriceData.price, twap5);
+
+			if (spotPosition.marketIndex === QUOTE_SPOT_MARKET_INDEX) {
+				const tokenAmount = getSignedTokenAmount(
+					getTokenAmount(
+						spotPosition.scaledBalance,
+						spotMarket,
+						spotPosition.balanceType
+					),
+					spotPosition.balanceType
+				);
+				if (isVariant(spotPosition.balanceType, 'deposit')) {
+					// add deposit value to total collateral
+					const tokenValue = getStrictTokenValue(
+						tokenAmount,
+						spotMarket.decimals,
+						strictOracle
+					);
+					calc.addCrossMarginTotalCollateral(tokenValue);
+				} else {
+					// borrow on quote contributes to margin requirement
+					const tokenValueAbs = getStrictTokenValue(
+						tokenAmount,
+						spotMarket.decimals,
+						strictOracle
+					).abs();
+					calc.addCrossMarginRequirement(tokenValueAbs, tokenValueAbs);
+					calc.addSpotLiability();
+				}
+				continue;
+			}
+
+			// Non-quote spot: worst-case simulation
+			const {
+				tokenAmount: worstCaseTokenAmount,
+				ordersValue: worstCaseOrdersValue,
+				tokenValue: worstCaseTokenValue,
+				weightedTokenValue: worstCaseWeightedTokenValue,
+			} = getWorstCaseTokenAmounts(
+				spotPosition,
+				spotMarket,
+				strictOracle,
+				marginCategory,
+				userCustomMarginRatio,
+				includeOpenOrders
+			);
+
+			// open order IM
+			calc.addCrossMarginRequirement(
+				new BN(spotPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT),
+				ZERO
+			);
+
+			if (worstCaseTokenAmount.gt(ZERO)) {
+				// asset side increases total collateral (weighted)
+				calc.addCrossMarginTotalCollateral(worstCaseWeightedTokenValue);
+			} else if (worstCaseTokenAmount.lt(ZERO)) {
+				// liability side increases margin requirement (weighted >= abs(token_value))
+				const liabilityWeighted = worstCaseWeightedTokenValue.abs();
+				calc.addCrossMarginRequirement(
+					liabilityWeighted,
+					worstCaseTokenValue.abs()
+				);
+				calc.addSpotLiability();
+				calc.addSpotLiabilityValue(worstCaseTokenValue.abs());
+			} else if (spotPosition.openOrders !== 0) {
+				calc.addSpotLiability();
+				calc.addSpotLiabilityValue(worstCaseTokenValue.abs());
+			}
+
+			// orders value contributes to collateral or requirement
+			if (worstCaseOrdersValue.gt(ZERO)) {
+				calc.addCrossMarginTotalCollateral(worstCaseOrdersValue);
+			} else if (worstCaseOrdersValue.lt(ZERO)) {
+				const absVal = worstCaseOrdersValue.abs();
+				calc.addCrossMarginRequirement(absVal, absVal);
+			}
+		}
+
+		// PERP POSITIONS
+		for (const marketPosition of this.getActivePerpPositions()) {
+			const market = this.driftClient.getPerpMarketAccount(
+				marketPosition.marketIndex
+			);
+			const quoteSpotMarket = this.driftClient.getSpotMarketAccount(
+				market.quoteSpotMarketIndex
+			);
+			const quoteOraclePriceData = this.getOracleDataForSpotMarket(
+				market.quoteSpotMarketIndex
+			);
+			const oraclePriceData = this.getOracleDataForPerpMarket(
+				market.marketIndex
+			);
+
+			// Worst-case perp liability and weighted pnl
+			const { worstCaseBaseAssetAmount, worstCaseLiabilityValue } =
+				calculateWorstCasePerpLiabilityValue(
+					marketPosition,
+					market,
+					oraclePriceData.price,
+					includeOpenOrders
+				);
+
+			// margin ratio for this perp
+			const customMarginRatio = Math.max(
+				this.getUserAccount().maxMarginRatio,
+				marketPosition.maxMarginRatio
+			);
+			let marginRatio = new BN(
+				calculateMarketMarginRatio(
+					market,
+					worstCaseBaseAssetAmount.abs(),
+					marginCategory,
+					customMarginRatio,
+					this.isHighLeverageMode(marginCategory) || enteringHighLeverage
+				)
+			);
+			if (isVariant(market.status, 'settlement')) {
+				marginRatio = ZERO;
+			}
+
+			// convert liability to quote value and apply margin ratio
+			const quotePrice = strict
+				? BN.max(
+						quoteOraclePriceData.price,
+						quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
+				  )
+				: quoteOraclePriceData.price;
+			let perpMarginRequirement = worstCaseLiabilityValue
+				.mul(quotePrice)
+				.div(PRICE_PRECISION)
+				.mul(marginRatio)
+				.div(MARGIN_PRECISION);
+			// add open orders IM
+			perpMarginRequirement = perpMarginRequirement.add(
+				new BN(marketPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
+			);
+
+			// weighted unrealized pnl
+			let positionUnrealizedPnl = calculatePositionPNL(
+				market,
+				marketPosition,
+				true,
+				oraclePriceData
+			);
+			let pnlQuotePrice: BN;
+			if (strict && positionUnrealizedPnl.gt(ZERO)) {
+				pnlQuotePrice = BN.min(
+					quoteOraclePriceData.price,
+					quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
+				);
+			} else if (strict && positionUnrealizedPnl.lt(ZERO)) {
+				pnlQuotePrice = BN.max(
+					quoteOraclePriceData.price,
+					quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
+				);
+			} else {
+				pnlQuotePrice = quoteOraclePriceData.price;
+			}
+			positionUnrealizedPnl = positionUnrealizedPnl
+				.mul(pnlQuotePrice)
+				.div(PRICE_PRECISION);
+
+			// Add perp contribution: isolated vs cross
+			const isIsolated = this.isPerpPositionIsolated(marketPosition);
+			if (isIsolated) {
+				// derive isolated quote deposit value, mirroring on-chain logic
+				let depositValue = ZERO;
+				if (marketPosition.isolatedPositionScaledBalance.gt(ZERO)) {
+					const quoteSpotMarket = this.driftClient.getSpotMarketAccount(
+						market.quoteSpotMarketIndex
+					);
+					const quoteOraclePriceData = this.getOracleDataForSpotMarket(
+						market.quoteSpotMarketIndex
+					);
+					const strictQuote = new StrictOraclePrice(
+						quoteOraclePriceData.price,
+						strict
+							? quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
+							: undefined
+					);
+					const quoteTokenAmount = getTokenAmount(
+						marketPosition.isolatedPositionScaledBalance,
+						quoteSpotMarket,
+						SpotBalanceType.DEPOSIT
+					);
+					depositValue = getStrictTokenValue(
+						quoteTokenAmount,
+						quoteSpotMarket.decimals,
+						strictQuote
+					);
+				}
+				calc.addIsolatedMarginCalculation(
+					market.marketIndex,
+					depositValue,
+					positionUnrealizedPnl,
+					worstCaseLiabilityValue,
+					perpMarginRequirement
+				);
+				calc.addPerpLiability();
+				calc.addPerpLiabilityValue(worstCaseLiabilityValue);
+			} else {
+				// cross: add to global requirement and collateral
+				calc.addCrossMarginRequirement(
+					perpMarginRequirement,
+					worstCaseLiabilityValue
+				);
+				calc.addCrossMarginTotalCollateral(positionUnrealizedPnl);
+				const hasPerpLiability =
+					!marketPosition.baseAssetAmount.eq(ZERO) ||
+					marketPosition.quoteAssetAmount.lt(ZERO) ||
+					marketPosition.openOrders !== 0;
+				if (hasPerpLiability) {
+					calc.addPerpLiability();
+				}
+			}
+		}
+
+		return calc;
+	}
+
+	private isPerpPositionIsolated(perpPosition: PerpPosition): boolean {
+		return (perpPosition.positionFlag & PositionFlag.IsolatedPosition) !== 0;
+	}
 }