@drift-labs/sdk 2.0.14 → 2.0.16

package/src/math/amm.ts

@@ -10,6 +10,9 @@ import {
 	QUOTE_PRECISION,
 	MARGIN_PRECISION,
 	PRICE_DIV_PEG,
+	PERCENTAGE_PRECISION,
+	BASE_PRECISION,
+	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
 } from '../constants/numericConstants';
 import {
 	AMM,
@@ -19,7 +22,7 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN, standardizeBaseAssetAmount } from '..';
+import { squareRootBN, clampBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -28,6 +31,8 @@ import {
 	calculateBudgetedPeg,
 } from './repeg';
 
+import { calculateLiveOracleStd } from './oracles';
+
 export function calculatePegFromTargetPrice(
 	targetPrice: BN,
 	baseAssetReserve: BN,
@@ -63,7 +68,8 @@ export function calculateOptimalPegAndBudget(
 	const totalFeeLB = amm.totalExchangeFee.div(new BN(2));
 	const budget = BN.max(ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
 	if (budget.lt(prePegCost)) {
-		const maxPriceSpread = new BN(amm.maxSpread)
+		const halfMaxPriceSpread = new BN(amm.maxSpread)
+			.div(new BN(2))
 			.mul(targetPrice)
 			.div(BID_ASK_SPREAD_PRECISION);
 
@@ -72,8 +78,8 @@ export function calculateOptimalPegAndBudget(
 		let newBudget: BN;
 		const targetPriceGap = reservePriceBefore.sub(targetPrice);
 
-		if (targetPriceGap.abs().gt(maxPriceSpread)) {
-			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
+		if (targetPriceGap.abs().gt(halfMaxPriceSpread)) {
+			const markAdj = targetPriceGap.abs().sub(halfMaxPriceSpread);
 
 			if (targetPriceGap.lt(new BN(0))) {
 				newTargetPrice = reservePriceBefore.add(markAdj);
@@ -173,6 +179,8 @@ export function calculateUpdatedAMM(
 
 	newAmm.totalFeeMinusDistributions =
 		newAmm.totalFeeMinusDistributions.sub(prepegCost);
+	newAmm.netRevenueSinceLastFunding =
+		newAmm.netRevenueSinceLastFunding.sub(prepegCost);
 
 	return newAmm;
 }
@@ -183,11 +191,15 @@ export function calculateUpdatedAMMSpreadReserves(
 	oraclePriceData: OraclePriceData
 ): { baseAssetReserve: BN; quoteAssetReserve: BN; sqrtK: BN; newPeg: BN } {
 	const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-	const dirReserves = calculateSpreadReserves(
+	const [shortReserves, longReserves] = calculateSpreadReserves(
 		newAmm,
-		direction,
 		oraclePriceData
 	);
+
+	const dirReserves = isVariant(direction, 'long')
+		? longReserves
+		: shortReserves;
+
 	const result = {
 		baseAssetReserve: dirReserves.baseAssetReserve,
 		quoteAssetReserve: dirReserves.quoteAssetReserve,
@@ -210,14 +222,8 @@ export function calculateBidAskPrice(
 		newAmm = amm;
 	}
 
-	const askReserves = calculateSpreadReserves(
+	const [bidReserves, askReserves] = calculateSpreadReserves(
 		newAmm,
-		PositionDirection.LONG,
-		oraclePriceData
-	);
-	const bidReserves = calculateSpreadReserves(
-		newAmm,
-		PositionDirection.SHORT,
 		oraclePriceData
 	);
 
@@ -315,14 +321,14 @@ export function calculateMarketOpenBidAsk(
 ): [BN, BN] {
 	// open orders
 	let openAsks;
-	if (maxBaseAssetReserve > baseAssetReserve) {
+	if (maxBaseAssetReserve.gt(baseAssetReserve)) {
 		openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new BN(-1));
 	} else {
 		openAsks = ZERO;
 	}
 
 	let openBids;
-	if (minBaseAssetReserve < baseAssetReserve) {
+	if (minBaseAssetReserve.lt(baseAssetReserve)) {
 		openBids = baseAssetReserve.sub(minBaseAssetReserve);
 	} else {
 		openBids = ZERO;
@@ -331,12 +337,18 @@ export function calculateMarketOpenBidAsk(
 }
 
 export function calculateInventoryScale(
-	netBaseAssetAmount: BN,
+	baseAssetAmountWithAmm: BN,
 	baseAssetReserve: BN,
 	minBaseAssetReserve: BN,
-	maxBaseAssetReserve: BN
+	maxBaseAssetReserve: BN,
+	directionalSpread: number,
+	maxSpread: number
 ): number {
-	const maxScale = BID_ASK_SPREAD_PRECISION.mul(new BN(10));
+	if (baseAssetAmountWithAmm.eq(ZERO)) {
+		return 0;
+	}
+
+	const defaultLargeBidAskFactor = BID_ASK_SPREAD_PRECISION.mul(new BN(10));
 	// inventory skew
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
 		baseAssetReserve,
@@ -348,13 +360,27 @@ export function calculateInventoryScale(
 		new BN(1),
 		BN.min(openBids.abs(), openAsks.abs())
 	);
-	const inventoryScale =
-		BN.min(
-			maxScale,
-			netBaseAssetAmount.mul(maxScale).div(minSideLiquidity).abs()
+
+	const inventoryScaleMax =
+		BN.max(
+			defaultLargeBidAskFactor,
+			new BN(maxSpread / 2)
+				.mul(BID_ASK_SPREAD_PRECISION)
+				.div(new BN(Math.max(directionalSpread, 1)))
 		).toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
 
-	return inventoryScale;
+	const inventoryScale =
+		baseAssetAmountWithAmm
+			.mul(BN.max(baseAssetAmountWithAmm.abs(), BASE_PRECISION))
+			.div(BASE_PRECISION)
+			.mul(defaultLargeBidAskFactor)
+			.div(minSideLiquidity)
+			.abs()
+			.toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
+
+	const inventorySpreadScale = Math.min(inventoryScaleMax, 1 + inventoryScale);
+
+	return inventorySpreadScale;
 }
 
 export function calculateEffectiveLeverage(
@@ -392,6 +418,48 @@ export function calculateMaxSpread(marginRatioInitial: number): number {
 	return maxTargetSpread;
 }
 
+export function calculateVolSpreadBN(
+	lastOracleConfPct: BN,
+	reservePrice: BN,
+	markStd: BN,
+	oracleStd: BN,
+	longIntensity: BN,
+	shortIntensity: BN,
+	volume24H: BN
+): [BN, BN] {
+	const marketAvgStdPct = markStd
+		.add(oracleStd)
+		.mul(PERCENTAGE_PRECISION)
+		.div(reservePrice)
+		.div(new BN(2));
+	const volSpread = BN.max(lastOracleConfPct, marketAvgStdPct.div(new BN(2)));
+
+	const clampMin = PERCENTAGE_PRECISION.div(new BN(100));
+	const clampMax = PERCENTAGE_PRECISION.mul(new BN(16)).div(new BN(10));
+
+	const longVolSpreadFactor = clampBN(
+		longIntensity.mul(PERCENTAGE_PRECISION).div(BN.max(ONE, volume24H)),
+		clampMin,
+		clampMax
+	);
+	const shortVolSpreadFactor = clampBN(
+		shortIntensity.mul(PERCENTAGE_PRECISION).div(BN.max(ONE, volume24H)),
+		clampMin,
+		clampMax
+	);
+
+	const longVolSpread = BN.max(
+		lastOracleConfPct,
+		volSpread.mul(longVolSpreadFactor).div(PERCENTAGE_PRECISION)
+	);
+	const shortVolSpread = BN.max(
+		lastOracleConfPct,
+		volSpread.mul(shortVolSpreadFactor).div(PERCENTAGE_PRECISION)
+	);
+
+	return [longVolSpread, shortVolSpread];
+}
+
 export function calculateSpreadBN(
 	baseSpread: number,
 	lastOracleReservePriceSpreadPct: BN,
@@ -400,27 +468,43 @@ export function calculateSpreadBN(
 	quoteAssetReserve: BN,
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
-	netBaseAssetAmount: BN,
+	baseAssetAmountWithAmm: BN,
 	reservePrice: BN,
 	totalFeeMinusDistributions: BN,
+	netRevenueSinceLastFunding: BN,
 	baseAssetReserve: BN,
 	minBaseAssetReserve: BN,
-	maxBaseAssetReserve: BN
+	maxBaseAssetReserve: BN,
+	markStd: BN,
+	oracleStd: BN,
+	longIntensity: BN,
+	shortIntensity: BN,
+	volume24H: BN
 ): [number, number] {
-	let longSpread = baseSpread / 2;
-	let shortSpread = baseSpread / 2;
+	const [longVolSpread, shortVolSpread] = calculateVolSpreadBN(
+		lastOracleConfPct,
+		reservePrice,
+		markStd,
+		oracleStd,
+		longIntensity,
+		shortIntensity,
+		volume24H
+	);
 
-	if (lastOracleReservePriceSpreadPct.gte(ZERO)) {
+	let longSpread = Math.max(baseSpread / 2, longVolSpread.toNumber());
+	let shortSpread = Math.max(baseSpread / 2, shortVolSpread.toNumber());
+
+	if (lastOracleReservePriceSpreadPct.gt(ZERO)) {
 		shortSpread = Math.max(
 			shortSpread,
 			lastOracleReservePriceSpreadPct.abs().toNumber() +
-				lastOracleConfPct.toNumber()
+				shortVolSpread.toNumber()
 		);
 	} else if (lastOracleReservePriceSpreadPct.lt(ZERO)) {
 		longSpread = Math.max(
 			longSpread,
 			lastOracleReservePriceSpreadPct.abs().toNumber() +
-				lastOracleConfPct.toNumber()
+				longVolSpread.toNumber()
 		);
 	}
 
@@ -429,57 +513,75 @@ export function calculateSpreadBN(
 		lastOracleReservePriceSpreadPct.abs().toNumber()
 	);
 
-	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = 10;
-
-	const inventoryScale = calculateInventoryScale(
-		netBaseAssetAmount,
+	const inventorySpreadScale = calculateInventoryScale(
+		baseAssetAmountWithAmm,
 		baseAssetReserve,
 		minBaseAssetReserve,
-		maxBaseAssetReserve
-	);
-	const inventorySpreadScale = Math.min(
-		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
-		1 + inventoryScale
+		maxBaseAssetReserve,
+		baseAssetAmountWithAmm.gt(ZERO) ? longSpread : shortSpread,
+		maxTargetSpread
 	);
 
-	if (netBaseAssetAmount.gt(ZERO)) {
+	if (baseAssetAmountWithAmm.gt(ZERO)) {
 		longSpread *= inventorySpreadScale;
-	} else if (netBaseAssetAmount.lt(ZERO)) {
+	} else if (baseAssetAmountWithAmm.lt(ZERO)) {
 		shortSpread *= inventorySpreadScale;
 	}
 
-	const effectiveLeverage = calculateEffectiveLeverage(
-		baseSpread,
-		quoteAssetReserve,
-		terminalQuoteAssetReserve,
-		pegMultiplier,
-		netBaseAssetAmount,
-		reservePrice,
-		totalFeeMinusDistributions
-	);
-
+	const MAX_SPREAD_SCALE = 10;
 	if (totalFeeMinusDistributions.gt(ZERO)) {
-		const spreadScale = Math.min(
-			MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
-			1 + effectiveLeverage
+		const effectiveLeverage = calculateEffectiveLeverage(
+			baseSpread,
+			quoteAssetReserve,
+			terminalQuoteAssetReserve,
+			pegMultiplier,
+			baseAssetAmountWithAmm,
+			reservePrice,
+			totalFeeMinusDistributions
 		);
-		if (netBaseAssetAmount.gt(ZERO)) {
+		const spreadScale = Math.min(MAX_SPREAD_SCALE, 1 + effectiveLeverage);
+		if (baseAssetAmountWithAmm.gt(ZERO)) {
 			longSpread *= spreadScale;
 		} else {
 			shortSpread *= spreadScale;
 		}
 	} else {
-		longSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
-		shortSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
+		longSpread *= MAX_SPREAD_SCALE;
+		shortSpread *= MAX_SPREAD_SCALE;
+	}
+
+	if (
+		netRevenueSinceLastFunding.lt(
+			DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT
+		)
+	) {
+		const retreatAmount = Math.min(
+			maxTargetSpread / 10,
+			Math.floor(
+				(baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
+					DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.toNumber()
+			)
+		);
+		const halfRetreatAmount = Math.floor(retreatAmount / 2);
+		if (baseAssetAmountWithAmm.gt(ZERO)) {
+			longSpread += retreatAmount;
+			shortSpread += halfRetreatAmount;
+		} else if (baseAssetAmountWithAmm.lt(ZERO)) {
+			longSpread += halfRetreatAmount;
+			shortSpread += retreatAmount;
+		} else {
+			longSpread += halfRetreatAmount;
+			shortSpread += halfRetreatAmount;
+		}
 	}
 
 	const totalSpread = longSpread + shortSpread;
 	if (totalSpread > maxTargetSpread) {
 		if (longSpread > shortSpread) {
-			longSpread = Math.min(longSpread, maxTargetSpread);
+			longSpread = Math.ceil((longSpread * maxTargetSpread) / totalSpread);
 			shortSpread = maxTargetSpread - longSpread;
 		} else {
-			shortSpread = Math.min(shortSpread, maxTargetSpread);
+			shortSpread = Math.ceil((shortSpread * maxTargetSpread) / totalSpread);
 			longSpread = maxTargetSpread - shortSpread;
 		}
 	}
@@ -489,11 +591,10 @@ export function calculateSpreadBN(
 
 export function calculateSpread(
 	amm: AMM,
-	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
-): number {
+): [number, number] {
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return amm.baseSpread / 2;
+		return [amm.baseSpread / 2, amm.baseSpread / 2];
 	}
 
 	const reservePrice = calculatePrice(
@@ -504,7 +605,6 @@ export function calculateSpread(
 
 	const targetPrice = oraclePriceData?.price || reservePrice;
 	const confInterval = oraclePriceData.confidence || ZERO;
-
 	const targetMarkSpreadPct = reservePrice
 		.sub(targetPrice)
 		.mul(BID_ASK_SPREAD_PRECISION)
@@ -514,6 +614,9 @@ export function calculateSpread(
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(reservePrice);
 
+	const now = new BN(new Date().getTime() / 1000); //todo
+	const liveOracleStd = calculateLiveOracleStd(amm, oraclePriceData, now);
+
 	const [longSpread, shortSpread] = calculateSpreadBN(
 		amm.baseSpread,
 		targetMarkSpreadPct,
@@ -525,55 +628,70 @@ export function calculateSpread(
 		amm.baseAssetAmountWithAmm,
 		reservePrice,
 		amm.totalFeeMinusDistributions,
+		amm.netRevenueSinceLastFunding,
 		amm.baseAssetReserve,
 		amm.minBaseAssetReserve,
-		amm.maxBaseAssetReserve
+		amm.maxBaseAssetReserve,
+		amm.markStd,
+		liveOracleStd,
+		amm.longIntensityVolume,
+		amm.shortIntensityVolume,
+		amm.volume24H
 	);
 
-	let spread: number;
-
-	if (isVariant(direction, 'long')) {
-		spread = longSpread;
-	} else {
-		spread = shortSpread;
-	}
-
-	return spread;
+	return [longSpread, shortSpread];
 }
 
 export function calculateSpreadReserves(
 	amm: AMM,
-	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
-): {
-	baseAssetReserve: BN;
-	quoteAssetReserve: BN;
-} {
-	const spread = calculateSpread(amm, direction, oraclePriceData);
+) {
+	function calculateSpreadReserve(
+		spread: number,
+		direction: PositionDirection,
+		amm: AMM
+	): {
+		baseAssetReserve;
+		quoteAssetReserve;
+	} {
+		if (spread === 0) {
+			return {
+				baseAssetReserve: amm.baseAssetReserve,
+				quoteAssetReserve: amm.quoteAssetReserve,
+			};
+		}
 
-	if (spread === 0) {
+		const quoteAssetReserveDelta = amm.quoteAssetReserve.div(
+			BID_ASK_SPREAD_PRECISION.div(new BN(spread / 2))
+		);
+
+		let quoteAssetReserve;
+		if (isVariant(direction, 'long')) {
+			quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
+		} else {
+			quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
+		}
+
+		const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
 		return {
-			baseAssetReserve: amm.baseAssetReserve,
-			quoteAssetReserve: amm.quoteAssetReserve,
+			baseAssetReserve,
+			quoteAssetReserve,
 		};
 	}
 
-	const quoteAsserReserveDelta = amm.quoteAssetReserve.div(
-		BID_ASK_SPREAD_PRECISION.div(new BN(spread / 2))
+	const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData);
+	const askReserves = calculateSpreadReserve(
+		longSpread,
+		PositionDirection.LONG,
+		amm
+	);
+	const bidReserves = calculateSpreadReserve(
+		shortSpread,
+		PositionDirection.SHORT,
+		amm
 	);
 
-	let quoteAssetReserve;
-	if (isVariant(direction, 'long')) {
-		quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
-	} else {
-		quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
-	}
-
-	const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
-	return {
-		baseAssetReserve,
-		quoteAssetReserve,
-	};
+	return [bidReserves, askReserves];
 }
 
 /**
@@ -665,12 +783,14 @@ export function calculateMaxBaseAssetAmountToTrade(
 		.div(PEG_PRECISION);
 
 	const newBaseAssetReserve = squareRootBN(newBaseAssetReserveSquared);
-
-	const baseAssetReserveBefore = calculateSpreadReserves(
+	const [shortSpreadReserves, longSpreadReserves] = calculateSpreadReserves(
 		amm,
-		direction,
 		oraclePriceData
-	).baseAssetReserve;
+	);
+
+	const baseAssetReserveBefore: BN = isVariant(direction, 'long')
+		? longSpreadReserves.baseAssetReserve
+		: shortSpreadReserves.baseAssetReserve;
 
 	if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
 		return [

package/src/math/oracles.ts

@@ -88,3 +88,55 @@ export function isOracleTooDivergent(
 
 	return tooDivergent;
 }
+
+export function calculateLiveOracleTwap(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	now: BN
+): BN {
+	const sinceLastUpdate = now.sub(
+		amm.historicalOracleData.lastOraclePriceTwapTs
+	);
+	const sinceStart = BN.max(ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+
+	const clampRange = amm.historicalOracleData.lastOraclePriceTwap.div(
+		new BN(3)
+	);
+
+	const clampedOraclePrice = BN.min(
+		amm.historicalOracleData.lastOraclePriceTwap.add(clampRange),
+		BN.max(
+			oraclePriceData.price,
+			amm.historicalOracleData.lastOraclePriceTwap.sub(clampRange)
+		)
+	);
+
+	const newOracleTwap = amm.historicalOracleData.lastOraclePriceTwap
+		.mul(sinceStart)
+		.add(clampedOraclePrice)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	return newOracleTwap;
+}
+
+export function calculateLiveOracleStd(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	now: BN
+): BN {
+	const sinceLastUpdate = now.sub(
+		amm.historicalOracleData.lastOraclePriceTwapTs
+	);
+	const sinceStart = BN.max(ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+
+	const liveOracleTwap = calculateLiveOracleTwap(amm, oraclePriceData, now);
+
+	const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).abs();
+
+	const oracleStd = priceDeltaVsTwap.add(
+		amm.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate))
+	);
+
+	return oracleStd;
+}

package/src/math/utils.ts

@@ -1,6 +1,10 @@
 import { BN } from '../';
 
-export const squareRootBN = (n, closeness = new BN(1)) => {
+export function clampBN(x: BN, min: BN, max: BN): BN {
+	return BN.max(min, BN.min(x, max));
+}
+
+export const squareRootBN = (n, closeness = new BN(1)): BN => {
 	// Assuming the sqrt of n as n only
 	let x = n;
 

package/src/types.ts

@@ -519,6 +519,8 @@ export type StateAccount = {
 	perpFeeStructure: FeeStructure;
 	spotFeeStructure: FeeStructure;
 	lpCooldownTime: BN;
+	initialPctToLiquidate: number;
+	liquidationDuration: number;
 };
 
 export type PerpMarketAccount = {
@@ -745,8 +747,8 @@ export type PerpPosition = {
 	settledPnl: BN;
 	lpShares: BN;
 	remainderBaseAssetAmount: number;
-	lastNetBaseAssetAmountPerLp: BN;
-	lastNetQuoteAssetAmountPerLp: BN;
+	lastBaseAssetAmountPerLp: BN;
+	lastQuoteAssetAmountPerLp: BN;
 };
 
 export type UserStatsAccount = {
@@ -790,6 +792,8 @@ export type UserAccount = {
 	totalWithdraws: BN;
 	totalSocialLoss: BN;
 	cumulativePerpFunding: BN;
+	liquidationMarginFreed: BN;
+	liquidationStartSlot: BN;
 };
 
 export type SpotPosition = {

package/src/user.ts

@@ -25,6 +25,7 @@ import {
 	SPOT_MARKET_WEIGHT_PRECISION,
 	QUOTE_SPOT_MARKET_INDEX,
 	TEN,
+	OPEN_ORDER_MARGIN_REQUIREMENT,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -163,8 +164,8 @@ export class User {
 			openAsks: ZERO,
 			settledPnl: ZERO,
 			lpShares: ZERO,
-			lastNetBaseAssetAmountPerLp: ZERO,
-			lastNetQuoteAssetAmountPerLp: ZERO,
+			lastBaseAssetAmountPerLp: ZERO,
+			lastQuoteAssetAmountPerLp: ZERO,
 		};
 	}
 
@@ -267,11 +268,11 @@ export class User {
 		const nShares = position.lpShares;
 
 		const deltaBaa = market.amm.baseAssetAmountPerLp
-			.sub(position.lastNetBaseAssetAmountPerLp)
+			.sub(position.lastBaseAssetAmountPerLp)
 			.mul(nShares)
 			.div(AMM_RESERVE_PRECISION);
 		const deltaQaa = market.amm.quoteAssetAmountPerLp
-			.sub(position.lastNetQuoteAssetAmountPerLp)
+			.sub(position.lastQuoteAssetAmountPerLp)
 			.mul(nShares)
 			.div(AMM_RESERVE_PRECISION);
 
@@ -593,6 +594,10 @@ export class User {
 						newTotalLiabilityValue.add(weightedTokenValue);
 				}
 
+				newTotalLiabilityValue = newTotalLiabilityValue.add(
+					new BN(spotPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
+				);
+
 				return newTotalLiabilityValue;
 			},
 			ZERO
@@ -893,6 +898,12 @@ export class User {
 					baseAssetValue = baseAssetValue
 						.mul(marginRatio)
 						.div(MARGIN_PRECISION);
+
+					if (includeOpenOrders) {
+						baseAssetValue = baseAssetValue.add(
+							new BN(perpPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
+						);
+					}
 				}
 
 				return totalPerpValue.add(baseAssetValue);
@@ -1251,8 +1262,8 @@ export class User {
 			openAsks: new BN(0),
 			settledPnl: ZERO,
 			lpShares: ZERO,
-			lastNetBaseAssetAmountPerLp: ZERO,
-			lastNetQuoteAssetAmountPerLp: ZERO,
+			lastBaseAssetAmountPerLp: ZERO,
+			lastQuoteAssetAmountPerLp: ZERO,
 		};
 
 		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);

package/tests/dlob/helpers.ts

@@ -37,8 +37,8 @@ export const mockPerpPosition: PerpPosition = {
 	settledPnl: new BN(0),
 	lpShares: new BN(0),
 	remainderBaseAssetAmount: 0,
-	lastNetBaseAssetAmountPerLp: new BN(0),
-	lastNetQuoteAssetAmountPerLp: new BN(0),
+	lastBaseAssetAmountPerLp: new BN(0),
+	lastQuoteAssetAmountPerLp: new BN(0),
 };
 
 export const mockAMM: AMM = {
@@ -486,6 +486,8 @@ export const mockStateAccount: StateAccount = {
 	numberOfSpotMarkets: 0,
 	numberOfSubAccounts: new BN(0),
 	numberOfAuthorities: new BN(0),
+	initialPctToLiquidate: 0,
+	liquidationDuration: 0,
 	oracleGuardRails: {
 		priceDivergence: {
 			markOracleDivergenceNumerator: new BN(0),