@drift-labs/sdk 2.92.0-beta.2 → 2.93.0-beta.0

package/src/math/margin.ts

@@ -5,6 +5,8 @@ import {
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
 	AMM_RESERVE_PRECISION,
+	MAX_PREDICTION_PRICE,
+	BASE_PRECISION,
 } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
@@ -99,6 +101,14 @@ export function calculateOraclePriceForPerpMargin(
 	return marginPrice;
 }
 
+/**
+ * This is _not_ the same as liability value as for prediction markets, the liability for the short in prediction market is (1 - oracle price) * base
+ * See {@link calculatePerpLiabilityValue} to get the liabiltiy value
+ * @param market
+ * @param perpPosition
+ * @param oraclePriceData
+ * @param includeOpenOrders
+ */
 export function calculateBaseAssetValueWithOracle(
 	market: PerpMarketAccount,
 	perpPosition: PerpPosition,
@@ -111,21 +121,76 @@ export function calculateBaseAssetValueWithOracle(
 	}
 
 	const baseAssetAmount = includeOpenOrders
-		? calculateWorstCaseBaseAssetAmount(perpPosition)
+		? calculateWorstCaseBaseAssetAmount(
+				perpPosition,
+				market,
+				oraclePriceData.price
+		  )
 		: perpPosition.baseAssetAmount;
 
 	return baseAssetAmount.abs().mul(price).div(AMM_RESERVE_PRECISION);
 }
 
 export function calculateWorstCaseBaseAssetAmount(
-	perpPosition: PerpPosition
+	perpPosition: PerpPosition,
+	perpMarket: PerpMarketAccount,
+	oraclePrice: BN
 ): BN {
+	return calculateWorstCasePerpLiabilityValue(
+		perpPosition,
+		perpMarket,
+		oraclePrice
+	).worstCaseBaseAssetAmount;
+}
+
+export function calculateWorstCasePerpLiabilityValue(
+	perpPosition: PerpPosition,
+	perpMarket: PerpMarketAccount,
+	oraclePrice: BN
+): { worstCaseBaseAssetAmount: BN; worstCaseLiabilityValue: BN } {
 	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
 	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
 
-	if (allBids.abs().gt(allAsks.abs())) {
-		return allBids;
+	const isPredictionMarket = isVariant(perpMarket.contractType, 'prediction');
+	const allBidsLiabilityValue = calculatePerpLiabilityValue(
+		allBids,
+		oraclePrice,
+		isPredictionMarket
+	);
+	const allAsksLiabilityValue = calculatePerpLiabilityValue(
+		allAsks,
+		oraclePrice,
+		isPredictionMarket
+	);
+
+	if (allAsksLiabilityValue.gte(allBidsLiabilityValue)) {
+		return {
+			worstCaseBaseAssetAmount: allAsks,
+			worstCaseLiabilityValue: allAsksLiabilityValue,
+		};
+	} else {
+		return {
+			worstCaseBaseAssetAmount: allBids,
+			worstCaseLiabilityValue: allBidsLiabilityValue,
+		};
+	}
+}
+
+export function calculatePerpLiabilityValue(
+	baseAssetAmount: BN,
+	oraclePrice: BN,
+	isPredictionMarket: boolean
+): BN {
+	if (isPredictionMarket) {
+		if (baseAssetAmount.gt(ZERO)) {
+			return baseAssetAmount.mul(oraclePrice).div(BASE_PRECISION);
+		} else {
+			return baseAssetAmount
+				.abs()
+				.mul(MAX_PREDICTION_PRICE.sub(oraclePrice))
+				.div(BASE_PRECISION);
+		}
 	} else {
-		return allAsks;
+		return baseAssetAmount.abs().mul(oraclePrice).div(BASE_PRECISION);
 	}
 }

package/src/types.ts

@@ -66,6 +66,7 @@ export enum UserStatus {
 export class ContractType {
 	static readonly PERPETUAL = { perpetual: {} };
 	static readonly FUTURE = { future: {} };
+	static readonly PREDICTION = { prediction: {} };
 }
 
 export class ContractTier {

package/src/user.ts

@@ -48,11 +48,13 @@ import {
 	BN,
 	calculateBaseAssetValue,
 	calculateMarketMarginRatio,
+	calculatePerpLiabilityValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
 	calculateReservePrice,
 	calculateSpotMarketMarginRatio,
 	calculateUnrealizedAssetWeight,
+	calculateWorstCasePerpLiabilityValue,
 	divCeil,
 	getBalance,
 	getSignedTokenAmount,
@@ -642,8 +644,15 @@ export class User {
 			undefined,
 			true
 		)[0];
+
+		const perpMarket = this.driftClient.getPerpMarketAccount(marketIndex);
+		const oraclePriceData = this.getOracleDataForPerpMarket(marketIndex);
 		const worstCaseBaseAssetAmount = perpPosition
-			? calculateWorstCaseBaseAssetAmount(perpPosition)
+			? calculateWorstCaseBaseAssetAmount(
+					perpPosition,
+					perpMarket,
+					oraclePriceData.price
+			  )
 			: ZERO;
 
 		const freeCollateral = this.getFreeCollateral().sub(collateralBuffer);
@@ -693,7 +702,7 @@ export class User {
 		strict = false,
 		includeOpenOrders = true
 	): BN {
-		return this.getTotalPerpPositionValue(
+		return this.getTotalPerpPositionLiability(
 			marginCategory,
 			liquidationBuffer,
 			includeOpenOrders,
@@ -1441,7 +1450,7 @@ export class User {
 		return health;
 	}
 
-	calculateWeightedPerpPositionValue(
+	calculateWeightedPerpPositionLiability(
 		perpPosition: PerpPosition,
 		marginCategory?: MarginCategory,
 		liquidationBuffer?: BN,
@@ -1469,14 +1478,25 @@ export class User {
 			valuationPrice = market.expiryPrice;
 		}
 
-		const baseAssetAmount = includeOpenOrders
-			? calculateWorstCaseBaseAssetAmount(perpPosition)
-			: perpPosition.baseAssetAmount;
-
-		let baseAssetValue = baseAssetAmount
-			.abs()
-			.mul(valuationPrice)
-			.div(BASE_PRECISION);
+		let baseAssetAmount: BN;
+		let liabilityValue;
+		if (includeOpenOrders) {
+			const { worstCaseBaseAssetAmount, worstCaseLiabilityValue } =
+				calculateWorstCasePerpLiabilityValue(
+					perpPosition,
+					market,
+					valuationPrice
+				);
+			baseAssetAmount = worstCaseBaseAssetAmount;
+			liabilityValue = worstCaseLiabilityValue;
+		} else {
+			baseAssetAmount = perpPosition.baseAssetAmount;
+			liabilityValue = calculatePerpLiabilityValue(
+				baseAssetAmount,
+				valuationPrice,
+				isVariant(market.contractType, 'prediction')
+			);
+		}
 
 		if (marginCategory) {
 			let marginRatio = new BN(
@@ -1513,19 +1533,19 @@ export class User {
 				quotePrice = quoteOraclePriceData.price;
 			}
 
-			baseAssetValue = baseAssetValue
+			liabilityValue = liabilityValue
 				.mul(quotePrice)
 				.div(PRICE_PRECISION)
 				.mul(marginRatio)
 				.div(MARGIN_PRECISION);
 
 			if (includeOpenOrders) {
-				baseAssetValue = baseAssetValue.add(
+				liabilityValue = liabilityValue.add(
 					new BN(perpPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
 				);
 
 				if (perpPosition.lpShares.gt(ZERO)) {
-					baseAssetValue = baseAssetValue.add(
+					liabilityValue = liabilityValue.add(
 						BN.max(
 							QUOTE_PRECISION,
 							valuationPrice
@@ -1539,7 +1559,7 @@ export class User {
 			}
 		}
 
-		return baseAssetValue;
+		return liabilityValue;
 	}
 
 	/**
@@ -1554,7 +1574,7 @@ export class User {
 		strict = false
 	): BN {
 		const perpPosition = this.getPerpPosition(marketIndex);
-		return this.calculateWeightedPerpPositionValue(
+		return this.calculateWeightedPerpPositionLiability(
 			perpPosition,
 			marginCategory,
 			liquidationBuffer,
@@ -1567,7 +1587,7 @@ export class User {
 	 * calculates sum of position value across all positions in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	getTotalPerpPositionValue(
+	getTotalPerpPositionLiability(
 		marginCategory?: MarginCategory,
 		liquidationBuffer?: BN,
 		includeOpenOrders?: boolean,
@@ -1575,7 +1595,7 @@ export class User {
 	): BN {
 		return this.getActivePerpPositions().reduce(
 			(totalPerpValue, perpPosition) => {
-				const baseAssetValue = this.calculateWeightedPerpPositionValue(
+				const baseAssetValue = this.calculateWeightedPerpPositionLiability(
 					perpPosition,
 					marginCategory,
 					liquidationBuffer,
@@ -1589,7 +1609,7 @@ export class User {
 	}
 
 	/**
-	 * calculates position value in margin system
+	 * calculates position value based on oracle
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getPerpPositionValue(
@@ -1615,6 +1635,41 @@ export class User {
 		);
 	}
 
+	/**
+	 * calculates position liabiltiy value in margin system
+	 * @returns : Precision QUOTE_PRECISION
+	 */
+	public getPerpLiabilityValue(
+		marketIndex: number,
+		oraclePriceData: OraclePriceData,
+		includeOpenOrders = false
+	): BN {
+		const userPosition =
+			this.getPerpPositionWithLPSettle(
+				marketIndex,
+				undefined,
+				false,
+				true
+			)[0] || this.getEmptyPosition(marketIndex);
+		const market = this.driftClient.getPerpMarketAccount(
+			userPosition.marketIndex
+		);
+
+		if (includeOpenOrders) {
+			return calculateWorstCasePerpLiabilityValue(
+				userPosition,
+				market,
+				oraclePriceData.price
+			).worstCaseLiabilityValue;
+		} else {
+			return calculatePerpLiabilityValue(
+				userPosition.baseAssetAmount,
+				oraclePriceData.price,
+				isVariant(market.contractType, 'prediction')
+			);
+		}
+	}
+
 	public getPositionSide(
 		currentPosition: Pick<PerpPosition, 'baseAssetAmount'>
 	): PositionDirection | undefined {
@@ -1730,7 +1785,7 @@ export class User {
 		spotAssetValue: BN;
 		spotLiabilityValue: BN;
 	} {
-		const perpLiability = this.getTotalPerpPositionValue(
+		const perpLiability = this.getTotalPerpPositionLiability(
 			marginCategory,
 			undefined,
 			includeOpenOrders
@@ -1806,7 +1861,11 @@ export class User {
 	}
 
 	getTotalLiabilityValue(marginCategory?: MarginCategory): BN {
-		return this.getTotalPerpPositionValue(marginCategory, undefined, true).add(
+		return this.getTotalPerpPositionLiability(
+			marginCategory,
+			undefined,
+			true
+		).add(
 			this.getSpotMarketLiabilityValue(
 				undefined,
 				marginCategory,
@@ -2167,6 +2226,8 @@ export class User {
 		const perpMarketWithSameOracle = this.driftClient
 			.getPerpMarketAccounts()
 			.find((market) => market.amm.oracle.equals(oracle));
+		const oraclePrice =
+			this.driftClient.getOracleDataForSpotMarket(marketIndex).price;
 		if (perpMarketWithSameOracle) {
 			const perpPosition = this.getPerpPositionWithLPSettle(
 				perpMarketWithSameOracle.marketIndex,
@@ -2178,7 +2239,8 @@ export class User {
 					this.calculateFreeCollateralDeltaForPerp(
 						perpMarketWithSameOracle,
 						perpPosition,
-						ZERO
+						ZERO,
+						oraclePrice
 					);
 
 				freeCollateralDelta = freeCollateralDelta.add(
@@ -2191,8 +2253,6 @@ export class User {
 			return new BN(-1);
 		}
 
-		const oraclePrice =
-			this.driftClient.getOracleDataForSpotMarket(marketIndex).price;
 		const liqPriceDelta = freeCollateral
 			.mul(QUOTE_PRECISION)
 			.div(freeCollateralDelta);
@@ -2263,6 +2323,7 @@ export class User {
 			market,
 			currentPerpPosition,
 			positionBaseSizeChange,
+			oraclePrice,
 			marginCategory,
 			includeOpenOrders
 		);
@@ -2350,41 +2411,62 @@ export class User {
 			freeCollateralChange = freeCollateralChange.sub(takerFee);
 		}
 
-		const baseAssetAmount = includeOpenOrders
-			? calculateWorstCaseBaseAssetAmount(perpPosition)
-			: perpPosition.baseAssetAmount;
+		const calculateMarginRequirement = (perpPosition: PerpPosition) => {
+			let baseAssetAmount: BN;
+			let liabilityValue: BN;
+			if (includeOpenOrders) {
+				const { worstCaseBaseAssetAmount, worstCaseLiabilityValue } =
+					calculateWorstCasePerpLiabilityValue(
+						perpPosition,
+						market,
+						oraclePrice
+					);
+				baseAssetAmount = worstCaseBaseAssetAmount;
+				liabilityValue = worstCaseLiabilityValue;
+			} else {
+				baseAssetAmount = perpPosition.baseAssetAmount;
+				liabilityValue = calculatePerpLiabilityValue(
+					baseAssetAmount,
+					oraclePrice,
+					isVariant(market.contractType, 'prediction')
+				);
+			}
 
-		const newBaseAssetAmount = baseAssetAmount.add(positionBaseSizeChange);
+			const marginRatio = calculateMarketMarginRatio(
+				market,
+				baseAssetAmount.abs(),
+				'Maintenance'
+			);
 
-		const newMarginRatio = calculateMarketMarginRatio(
-			market,
-			newBaseAssetAmount.abs(),
-			'Maintenance'
-		);
+			return liabilityValue.mul(new BN(marginRatio)).div(MARGIN_PRECISION);
+		};
+
+		const freeCollateralConsumptionBefore =
+			calculateMarginRequirement(perpPosition);
 
-		// update free collateral to account for new margin requirement from position change
-		freeCollateralChange = freeCollateralChange.sub(
-			newBaseAssetAmount
-				.abs()
-				.sub(baseAssetAmount.abs())
-				.mul(oraclePrice)
-				.div(BASE_PRECISION)
-				.mul(new BN(newMarginRatio))
-				.div(MARGIN_PRECISION)
+		const perpPositionAfter = Object.assign({}, perpPosition);
+		perpPositionAfter.baseAssetAmount = perpPositionAfter.baseAssetAmount.add(
+			positionBaseSizeChange
 		);
 
-		return freeCollateralChange;
+		const freeCollateralConsumptionAfter =
+			calculateMarginRequirement(perpPositionAfter);
+
+		return freeCollateralChange.sub(
+			freeCollateralConsumptionAfter.sub(freeCollateralConsumptionBefore)
+		);
 	}
 
 	calculateFreeCollateralDeltaForPerp(
 		market: PerpMarketAccount,
 		perpPosition: PerpPosition,
 		positionBaseSizeChange: BN,
+		oraclePrice: BN,
 		marginCategory: MarginCategory = 'Maintenance',
 		includeOpenOrders = false
 	): BN | undefined {
 		const baseAssetAmount = includeOpenOrders
-			? calculateWorstCaseBaseAssetAmount(perpPosition)
+			? calculateWorstCaseBaseAssetAmount(perpPosition, market, oraclePrice)
 			: perpPosition.baseAssetAmount;
 
 		// zero if include orders == false
@@ -2409,23 +2491,33 @@ export class User {
 		}
 
 		let freeCollateralDelta = ZERO;
-		if (proposedBaseAssetAmount.gt(ZERO)) {
-			freeCollateralDelta = QUOTE_PRECISION.sub(marginRatioQuotePrecision)
-				.mul(proposedBaseAssetAmount)
-				.div(BASE_PRECISION);
+		if (isVariant(market.contractType, 'prediction')) {
+			// for prediction market, increase in pnl and margin requirement will net out for position
+			// open order margin requirement will change with price though
+			if (orderBaseAssetAmount.gt(ZERO)) {
+				freeCollateralDelta = marginRatioQuotePrecision.neg();
+			} else if (orderBaseAssetAmount.lt(ZERO)) {
+				freeCollateralDelta = marginRatioQuotePrecision;
+			}
 		} else {
-			freeCollateralDelta = QUOTE_PRECISION.neg()
-				.sub(marginRatioQuotePrecision)
-				.mul(proposedBaseAssetAmount.abs())
-				.div(BASE_PRECISION);
-		}
+			if (proposedBaseAssetAmount.gt(ZERO)) {
+				freeCollateralDelta = QUOTE_PRECISION.sub(marginRatioQuotePrecision)
+					.mul(proposedBaseAssetAmount)
+					.div(BASE_PRECISION);
+			} else {
+				freeCollateralDelta = QUOTE_PRECISION.neg()
+					.sub(marginRatioQuotePrecision)
+					.mul(proposedBaseAssetAmount.abs())
+					.div(BASE_PRECISION);
+			}
 
-		if (!orderBaseAssetAmount.eq(ZERO)) {
-			freeCollateralDelta = freeCollateralDelta.sub(
-				marginRatioQuotePrecision
-					.mul(orderBaseAssetAmount.abs())
-					.div(BASE_PRECISION)
-			);
+			if (!orderBaseAssetAmount.eq(ZERO)) {
+				freeCollateralDelta = freeCollateralDelta.sub(
+					marginRatioQuotePrecision
+						.mul(orderBaseAssetAmount.abs())
+						.div(BASE_PRECISION)
+				);
+			}
 		}
 
 		return freeCollateralDelta;
@@ -2519,13 +2611,16 @@ export class User {
 	 *
 	 * @param targetMarketIndex
 	 * @param tradeSide
-	 * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
+	 * @param isLp
+	 * @returns { tradeSize: BN, oppositeSideTradeSize: BN} : Precision QUOTE_PRECISION
 	 */
 	public getMaxTradeSizeUSDCForPerp(
 		targetMarketIndex: number,
 		tradeSide: PositionDirection,
 		isLp = false
-	): BN {
+	): { tradeSize: BN; oppositeSideTradeSize: BN } {
+		let tradeSize = ZERO;
+		let oppositeSideTradeSize = ZERO;
 		const currentPosition =
 			this.getPerpPositionWithLPSettle(targetMarketIndex, undefined, true)[0] ||
 			this.getEmptyPosition(targetMarketIndex);
@@ -2552,41 +2647,49 @@ export class User {
 			: ZERO;
 
 		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
-		const oppositeSizeValueUSDC = targetingSameSide
+		const oppositeSizeLiabilityValue = targetingSameSide
 			? ZERO
-			: this.getPerpPositionValue(targetMarketIndex, oracleData);
+			: calculatePerpLiabilityValue(
+					currentPosition.baseAssetAmount,
+					oracleData.price,
+					isVariant(marketAccount.contractType, 'prediction')
+			  );
 
-		let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex, lpBuffer);
+		const maxPositionSize = this.getPerpBuyingPower(
+			targetMarketIndex,
+			lpBuffer
+		);
 
 		if (maxPositionSize.gte(ZERO)) {
-			if (oppositeSizeValueUSDC.eq(ZERO)) {
+			if (oppositeSizeLiabilityValue.eq(ZERO)) {
 				// case 1 : Regular trade where current total position less than max, and no opposite position to account for
 				// do nothing
+				tradeSize = maxPositionSize;
 			} else {
 				// case 2 : trade where current total position less than max, but need to account for flipping the current position over to the other side
-				maxPositionSize = maxPositionSize.add(
-					oppositeSizeValueUSDC.mul(new BN(2))
-				);
+				tradeSize = maxPositionSize.add(oppositeSizeLiabilityValue);
+				oppositeSideTradeSize = oppositeSizeLiabilityValue;
 			}
 		} else {
 			// current leverage is greater than max leverage - can only reduce position size
 
 			if (!targetingSameSide) {
 				const market = this.driftClient.getPerpMarketAccount(targetMarketIndex);
-				const perpPositionValue = this.getPerpPositionValue(
-					targetMarketIndex,
-					oracleData
+				const perpLiabilityValue = calculatePerpLiabilityValue(
+					currentPosition.baseAssetAmount,
+					oracleData.price,
+					isVariant(market.contractType, 'prediction')
 				);
 				const totalCollateral = this.getTotalCollateral();
 				const marginRequirement = this.getInitialMarginRequirement();
-				const marginFreedByClosing = perpPositionValue
+				const marginFreedByClosing = perpLiabilityValue
 					.mul(new BN(market.marginRatioInitial))
 					.div(MARGIN_PRECISION);
 				const marginRequirementAfterClosing =
 					marginRequirement.sub(marginFreedByClosing);
 
 				if (marginRequirementAfterClosing.gt(totalCollateral)) {
-					maxPositionSize = perpPositionValue;
+					oppositeSideTradeSize = perpLiabilityValue;
 				} else {
 					const freeCollateralAfterClose = totalCollateral.sub(
 						marginRequirementAfterClosing
@@ -2598,14 +2701,16 @@ export class User {
 							freeCollateralAfterClose,
 							ZERO
 						);
-					maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
+					oppositeSideTradeSize = perpLiabilityValue;
+					tradeSize = buyingPowerAfterClose;
 				}
 			} else {
 				// do nothing if targetting same side
+				tradeSize = maxPositionSize;
 			}
 		}
 
-		return maxPositionSize;
+		return { tradeSize, oppositeSideTradeSize };
 	}
 
 	/**
@@ -3235,16 +3340,19 @@ export class User {
 			this.getPerpPositionWithLPSettle(targetMarketIndex)[0] ||
 			this.getEmptyPosition(targetMarketIndex);
 
+		const perpMarket = this.driftClient.getPerpMarketAccount(targetMarketIndex);
 		const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
 
-		let currentPositionQuoteAmount = this.getPerpPositionValue(
-			targetMarketIndex,
-			oracleData,
-			includeOpenOrders
+		let {
+			// eslint-disable-next-line prefer-const
+			worstCaseBaseAssetAmount: worstCaseBase,
+			worstCaseLiabilityValue: currentPositionQuoteAmount,
+		} = calculateWorstCasePerpLiabilityValue(
+			currentPosition,
+			perpMarket,
+			oracleData.price
 		);
 
-		const worstCaseBase = calculateWorstCaseBaseAssetAmount(currentPosition);
-
 		// current side is short if position base asset amount is negative OR there is no position open but open orders are short
 		const currentSide =
 			currentPosition.baseAssetAmount.isNeg() ||
@@ -3617,8 +3725,14 @@ export class User {
 				perpMarket.marketIndex
 			);
 			const oraclePrice = oraclePriceData.price;
-			const worstCaseBaseAmount =
-				calculateWorstCaseBaseAssetAmount(settledLpPosition);
+			const {
+				worstCaseBaseAssetAmount: worstCaseBaseAmount,
+				worstCaseLiabilityValue,
+			} = calculateWorstCasePerpLiabilityValue(
+				settledLpPosition,
+				perpMarket,
+				oraclePrice
+			);
 
 			const marginRatio = new BN(
 				calculateMarketMarginRatio(
@@ -3636,12 +3750,7 @@ export class User {
 				QUOTE_SPOT_MARKET_INDEX
 			);
 
-			const baseAssetValue = worstCaseBaseAmount
-				.abs()
-				.mul(oraclePrice)
-				.div(BASE_PRECISION);
-
-			let marginRequirement = baseAssetValue
+			let marginRequirement = worstCaseLiabilityValue
 				.mul(quoteOraclePriceData.price)
 				.div(PRICE_PRECISION)
 				.mul(marginRatio)
@@ -3667,7 +3776,7 @@ export class User {
 			healthComponents.perpPositions.push({
 				marketIndex: perpMarket.marketIndex,
 				size: worstCaseBaseAmount,
-				value: baseAssetValue,
+				value: worstCaseLiabilityValue,
 				weight: marginRatio,
 				weightedValue: marginRequirement,
 			});
@@ -3842,14 +3951,14 @@ export class User {
 
 		let currentPerpPositionValueUSDC = ZERO;
 		if (currentPerpPosition) {
-			currentPerpPositionValueUSDC = this.getPerpPositionValue(
+			currentPerpPositionValueUSDC = this.getPerpLiabilityValue(
 				marketToIgnore,
 				oracleData,
 				includeOpenOrders
 			);
 		}
 
-		return this.getTotalPerpPositionValue(
+		return this.getTotalPerpPositionLiability(
 			marginCategory,
 			liquidationBuffer,
 			includeOpenOrders