@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/math/market.ts

@@ -1,10 +1,11 @@
 import { BN } from '@project-serum/anchor';
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
-	calculateSpreadReserves,
+	calculateUpdatedAMMSpreadReserves,
 	getSwapDirection,
+	calculateUpdatedAMM,
 } from './amm';
 import { OraclePriceData } from '../oracles/types';
 
@@ -14,11 +15,15 @@ import { OraclePriceData } from '../oracles/types';
  * @param market
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
-export function calculateMarkPrice(market: Market): BN {
+export function calculateMarkPrice(
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
 	return calculatePrice(
-		market.amm.baseAssetReserve,
-		market.amm.quoteAssetReserve,
-		market.amm.pegMultiplier
+		newAmm.baseAssetReserve,
+		newAmm.quoteAssetReserve,
+		newAmm.pegMultiplier
 	);
 }
 
@@ -28,17 +33,18 @@ export function calculateMarkPrice(market: Market): BN {
  * @param market
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
-export function calculateBidPrice(market: Market): BN {
-	const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-		market.amm,
-		PositionDirection.SHORT
-	);
+export function calculateBidPrice(
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const { baseAssetReserve, quoteAssetReserve, newPeg } =
+		calculateUpdatedAMMSpreadReserves(
+			market.amm,
+			PositionDirection.SHORT,
+			oraclePriceData
+		);
 
-	return calculatePrice(
-		baseAssetReserve,
-		quoteAssetReserve,
-		market.amm.pegMultiplier
-	);
+	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 
 /**
@@ -47,24 +53,25 @@ export function calculateBidPrice(market: Market): BN {
  * @param market
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
-export function calculateAskPrice(market: Market): BN {
-	const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-		market.amm,
-		PositionDirection.LONG
-	);
+export function calculateAskPrice(
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const { baseAssetReserve, quoteAssetReserve, newPeg } =
+		calculateUpdatedAMMSpreadReserves(
+			market.amm,
+			PositionDirection.LONG,
+			oraclePriceData
+		);
 
-	return calculatePrice(
-		baseAssetReserve,
-		quoteAssetReserve,
-		market.amm.pegMultiplier
-	);
+	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 
 export function calculateNewMarketAfterTrade(
 	baseAssetAmount: BN,
 	direction: PositionDirection,
-	market: Market
-): Market {
+	market: MarketAccount
+): MarketAccount {
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
@@ -83,10 +90,10 @@ export function calculateNewMarketAfterTrade(
 }
 
 export function calculateMarkOracleSpread(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const markPrice = calculateMarkPrice(market);
+	const markPrice = calculateMarkPrice(market, oraclePriceData);
 	return calculateOracleSpread(markPrice, oraclePriceData);
 }
 

package/src/math/oracles.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOracleValid = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
+    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const isOraclePriceTooVolatile = oraclePriceData.price
+        .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
+        .gt(oracleGuardRails.validity.tooVolatileRatio) ||
+        amm.lastOraclePriceTwap
+            .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
+            .gt(oracleGuardRails.validity.tooVolatileRatio);
+    const isConfidenceTooLarge = oraclePriceData.price
+        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+    const oracleIsStale = oraclePriceData.slot
+        .sub(new index_1.BN(slot))
+        .gt(oracleGuardRails.validity.slotsBeforeStale);
+    return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
+        oracleIsStale ||
+        isOraclePriceNonPositive ||
+        isOraclePriceTooVolatile ||
+        isConfidenceTooLarge);
+}
+exports.isOracleValid = isOracleValid;

package/src/math/orders.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@project-serum/anchor");
+const auction_1 = require("./auction");
+const market_1 = require("./market");
+function isOrderRiskIncreasing(user, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if no position exists, it's risk increasing
+    if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return true;
+    }
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return true;
+    }
+    const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    // if order will flip position
+    if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(numericConstants_1.TWO))) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
+function isOrderRiskIncreasingInSameDirection(user, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if no position exists, it's risk increasing
+    if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return true;
+    }
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
+function isOrderReduceOnly(user, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if position is long and order is long
+    if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'long')) {
+        return false;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return false;
+    }
+    return true;
+}
+exports.isOrderReduceOnly = isOrderReduceOnly;
+function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
+    const remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function getLimitPrice(order, market, oraclePriceData, slot) {
+    let limitPrice;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    else if (types_1.isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+        if (auction_1.isAuctionComplete(order, slot)) {
+            limitPrice = auction_1.getAuctionPrice(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else if (types_1.isVariant(order.direction, 'long')) {
+            const askPrice = market_1.calculateAskPrice(market, oraclePriceData);
+            const delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = askPrice.add(delta);
+        }
+        else {
+            const bidPrice = market_1.calculateBidPrice(market, oraclePriceData);
+            const delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = bidPrice.sub(delta);
+        }
+    }
+    else {
+        limitPrice = order.price;
+    }
+    return limitPrice;
+}
+exports.getLimitPrice = getLimitPrice;

package/src/math/orders.ts

@@ -1,6 +1,10 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
+import { isOneOfVariant, isVariant, MarketAccount, Order } from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { getAuctionPrice, isAuctionComplete } from './auction';
+import { calculateAskPrice, calculateBidPrice } from './market';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -106,3 +110,41 @@ export function isOrderReduceOnly(
 
 	return true;
 }
+
+export function standardizeBaseAssetAmount(
+	baseAssetAmount: BN,
+	stepSize: BN
+): BN {
+	const remainder = baseAssetAmount.mod(stepSize);
+	return baseAssetAmount.sub(remainder);
+}
+
+export function getLimitPrice(
+	order: Order,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN {
+	let limitPrice;
+	if (!order.oraclePriceOffset.eq(ZERO)) {
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+		if (isAuctionComplete(order, slot)) {
+			limitPrice = getAuctionPrice(order, slot);
+		} else if (!order.price.eq(ZERO)) {
+			limitPrice = order.price;
+		} else if (isVariant(order.direction, 'long')) {
+			const askPrice = calculateAskPrice(market, oraclePriceData);
+			const delta = askPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = askPrice.add(delta);
+		} else {
+			const bidPrice = calculateBidPrice(market, oraclePriceData);
+			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = bidPrice.sub(delta);
+		}
+	} else {
+		limitPrice = order.price;
+	}
+
+	return limitPrice;
+}

package/src/math/position.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+const __1 = require("../");
+const numericConstants_1 = require("../constants/numericConstants");
+const types_1 = require("../types");
+const amm_1 = require("./amm");
+/**
+ * calculateBaseAssetValue
+ * = market value of closing entire position
+ * @param market
+ * @param userPosition
+ * @param oraclePriceData
+ * @returns Base Asset Value. : Precision QUOTE_PRECISION
+ */
+function calculateBaseAssetValue(market, userPosition, oraclePriceData) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const directionToClose = findDirectionToClose(userPosition);
+    let prepegAmm;
+    if (market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, directionToClose, oraclePriceData);
+        prepegAmm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        prepegAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
+    }
+    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), amm_1.getSwapDirection('base', directionToClose));
+    switch (directionToClose) {
+        case types_1.PositionDirection.SHORT:
+            return prepegAmm.quoteAssetReserve
+                .sub(newQuoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+        case types_1.PositionDirection.LONG:
+            return newQuoteAssetReserve
+                .sub(prepegAmm.quoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+                .add(numericConstants_1.ONE);
+    }
+}
+exports.calculateBaseAssetValue = calculateBaseAssetValue;
+/**
+ * calculatePositionPNL
+ * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
+ * @param market
+ * @param marketPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
+    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
+    let pnl;
+    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
+    }
+    else {
+        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
+    }
+    if (withFunding) {
+        const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        pnl = pnl.add(fundingRatePnL);
+    }
+    return pnl;
+}
+exports.calculatePositionPNL = calculatePositionPNL;
+/**
+ *
+ * @param market
+ * @param marketPosition
+ * @returns // TODO-PRECISION
+ */
+function calculatePositionFundingPNL(market, marketPosition) {
+    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    let ammCumulativeFundingRate;
+    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+    }
+    else {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+    }
+    const perPositionFundingRate = ammCumulativeFundingRate
+        .sub(marketPosition.lastCumulativeFundingRate)
+        .mul(marketPosition.baseAssetAmount)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
+        .mul(new __1.BN(-1));
+    return perPositionFundingRate;
+}
+exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
+function positionIsAvailable(position) {
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders.eq(numericConstants_1.ZERO) &&
+        position.unsettledPnl.eq(numericConstants_1.ZERO));
+}
+exports.positionIsAvailable = positionIsAvailable;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateEntryPrice(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateEntryPrice = calculateEntryPrice;
+function findDirectionToClose(userPosition) {
+    return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.SHORT
+        : types_1.PositionDirection.LONG;
+}
+exports.findDirectionToClose = findDirectionToClose;
+function positionCurrentDirection(userPosition) {
+    return userPosition.baseAssetAmount.gte(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.LONG
+        : types_1.PositionDirection.SHORT;
+}
+exports.positionCurrentDirection = positionCurrentDirection;
+function isEmptyPosition(userPosition) {
+    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
+}
+exports.isEmptyPosition = isEmptyPosition;

package/src/math/position.ts

@@ -9,29 +9,54 @@ import {
 	PRICE_TO_QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { Market, PositionDirection, UserPosition } from '../types';
-import { calculateAmmReservesAfterSwap, getSwapDirection } from './amm';
-import { SETTLEMENT_RATIO_PRECISION, SETTLEMENT_RATIOS } from '../settlement';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import {
+	calculateUpdatedAMM,
+	calculateUpdatedAMMSpreadReserves,
+	calculateAmmReservesAfterSwap,
+	getSwapDirection,
+} from './amm';
 
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
  * @param market
  * @param userPosition
+ * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
 export function calculateBaseAssetValue(
-	market: Market,
-	userPosition: UserPosition
+	market: MarketAccount,
+	userPosition: UserPosition,
+	oraclePriceData: OraclePriceData
 ): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	const directionToClose = findDirectionToClose(userPosition);
+	let prepegAmm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+
+	if (market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(
+				market.amm,
+				directionToClose,
+				oraclePriceData
+			);
+		prepegAmm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
+		};
+	} else {
+		prepegAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+	}
 
 	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
-		market.amm,
+		prepegAmm,
 		'base',
 		userPosition.baseAssetAmount.abs(),
 		getSwapDirection('base', directionToClose)
@@ -39,15 +64,15 @@ export function calculateBaseAssetValue(
 
 	switch (directionToClose) {
 		case PositionDirection.SHORT:
-			return market.amm.quoteAssetReserve
+			return prepegAmm.quoteAssetReserve
 				.sub(newQuoteAssetReserve)
-				.mul(market.amm.pegMultiplier)
+				.mul(prepegAmm.pegMultiplier)
 				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
 
 		case PositionDirection.LONG:
 			return newQuoteAssetReserve
-				.sub(market.amm.quoteAssetReserve)
-				.mul(market.amm.pegMultiplier)
+				.sub(prepegAmm.quoteAssetReserve)
+				.mul(prepegAmm.pegMultiplier)
 				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
 				.add(ONE);
 	}
@@ -62,15 +87,20 @@ export function calculateBaseAssetValue(
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
-	market: Market,
+	market: MarketAccount,
 	marketPosition: UserPosition,
-	withFunding = false
+	withFunding = false,
+	oraclePriceData: OraclePriceData
 ): BN {
 	if (marketPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
-	const baseAssetValue = calculateBaseAssetValue(market, marketPosition);
+	const baseAssetValue = calculateBaseAssetValue(
+		market,
+		marketPosition,
+		oraclePriceData
+	);
 
 	let pnl;
 	if (marketPosition.baseAssetAmount.gt(ZERO)) {
@@ -91,27 +121,6 @@ export function calculatePositionPNL(
 	return pnl;
 }
 
-export function calculateSettledPositionPNL(
-	market: Market,
-	marketPosition: UserPosition
-): BN {
-	let pnl = calculatePositionPNL(market, marketPosition);
-
-	if (pnl.gt(ZERO)) {
-		try {
-			pnl = pnl
-				.mul(new BN(SETTLEMENT_RATIOS[marketPosition.marketIndex.toNumber()]))
-				.div(SETTLEMENT_RATIO_PRECISION);
-		} catch (e) {
-			console.log(pnl.toString());
-			console.log(marketPosition.marketIndex.toNumber());
-			throw e;
-		}
-	}
-
-	return pnl;
-}
-
 /**
  *
  * @param market
@@ -119,7 +128,7 @@ export function calculateSettledPositionPNL(
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(
-	market: Market,
+	market: MarketAccount,
 	marketPosition: UserPosition
 ): BN {
 	if (marketPosition.baseAssetAmount.eq(ZERO)) {
@@ -143,6 +152,14 @@ export function calculatePositionFundingPNL(
 	return perPositionFundingRate;
 }
 
+export function positionIsAvailable(position: UserPosition): boolean {
+	return (
+		position.baseAssetAmount.eq(ZERO) &&
+		position.openOrders.eq(ZERO) &&
+		position.unsettledPnl.eq(ZERO)
+	);
+}
+
 /**
  *
  * @param userPosition