@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/math/orders.js

@@ -0,0 +1,153 @@
+"use strict";
+exports.__esModule = true;
+exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+var types_1 = require("../types");
+var numericConstants_1 = require("../constants/numericConstants");
+var anchor_1 = require("@project-serum/anchor");
+var auction_1 = require("./auction");
+var market_1 = require("./market");
+var amm_1 = require("./amm");
+function isOrderRiskIncreasing(user, order) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    var 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) && (0, types_1.isVariant)(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return true;
+    }
+    var 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 ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    var 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) && (0, types_1.isVariant)(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
+function isOrderReduceOnly(user, order) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    var position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if position is long and order is long
+    if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'long')) {
+        return false;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return false;
+    }
+    return true;
+}
+exports.isOrderReduceOnly = isOrderReduceOnly;
+function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
+    var remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function getLimitPrice(order, market, oraclePriceData, slot) {
+    var limitPrice;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+        if (!(0, auction_1.isAuctionComplete)(order, slot)) {
+            limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else if ((0, types_1.isVariant)(order.direction, 'long')) {
+            var askPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+            var delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = askPrice.add(delta);
+        }
+        else {
+            var bidPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+            var delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = bidPrice.sub(delta);
+        }
+    }
+    else {
+        limitPrice = order.price;
+    }
+    return limitPrice;
+}
+exports.getLimitPrice = getLimitPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot, maxAuctionDuration) {
+    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
+        isOrderExpired(order, slot, maxAuctionDuration));
+}
+exports.isFillableByVAMM = isFillableByVAMM;
+function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+        order.triggered === false) {
+        return numericConstants_1.ZERO;
+    }
+    var limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+    var baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData);
+    var maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(market.amm, order.direction);
+    return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData) {
+    var _a = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData), maxAmountToTrade = _a[0], direction = _a[1];
+    var baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
+    // Check that directions are the same
+    var sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    return baseAssetAmount.gt(order.baseAssetAmount)
+        ? order.baseAssetAmount
+        : baseAssetAmount;
+}
+exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
+function isSameDirection(firstDirection, secondDirection) {
+    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
+        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
+}
+function isOrderExpired(order, slot, maxAuctionDuration) {
+    if (!(0, types_1.isVariant)(order.orderType, 'market') ||
+        !(0, types_1.isVariant)(order.status, 'open')) {
+        return false;
+    }
+    return new anchor_1.BN(slot).sub(order.slot).gt(new anchor_1.BN(maxAuctionDuration));
+}
+exports.isOrderExpired = isOrderExpired;

package/src/math/orders.ts

@@ -2,7 +2,7 @@ import { ClearingHouseUser } from '../clearingHouseUser';
 import {
 	isOneOfVariant,
 	isVariant,
-	MarketAccount,
+	PerpMarketAccount,
 	Order,
 	PositionDirection,
 } from '../types';
@@ -131,7 +131,7 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
@@ -161,7 +161,7 @@ export function getLimitPrice(
 
 export function isFillableByVAMM(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number,
 	maxAuctionDuration: number
@@ -180,7 +180,7 @@ export function isFillableByVAMM(
 
 export function calculateBaseAssetAmountForAmmToFulfill(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
@@ -209,7 +209,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 
 export function calculateBaseAssetAmountToFillUpToLimitPrice(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	limitPrice: BN,
 	oraclePriceData: OraclePriceData
 ): BN {

package/src/math/position.js

@@ -0,0 +1,172 @@
+"use strict";
+exports.__esModule = true;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledPnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+var __1 = require("../");
+var numericConstants_1 = require("../constants/numericConstants");
+var types_1 = require("../types");
+var amm_1 = require("./amm");
+var margin_1 = require("./margin");
+/**
+ * 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;
+    }
+    var directionToClose = findDirectionToClose(userPosition);
+    var prepegAmm;
+    if (market.amm.baseSpread > 0) {
+        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, sqrtK = _a.sqrtK, newPeg = _a.newPeg;
+        prepegAmm = {
+            baseAssetReserve: baseAssetReserve,
+            quoteAssetReserve: quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg
+        };
+    }
+    else {
+        prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    }
+    var _b = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose)), newQuoteAssetReserve = _b[0], _ = _b[1];
+    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 PerpPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+function calculatePositionPNL(market, perpPosition, withFunding, oraclePriceData) {
+    if (withFunding === void 0) { withFunding = false; }
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return perpPosition.quoteAssetAmount;
+    }
+    var baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    var baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    var pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(perpPosition.quoteAssetAmount);
+    if (withFunding) {
+        var fundingRatePnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        pnl = pnl.add(fundingRatePnL);
+    }
+    return pnl;
+}
+exports.calculatePositionPNL = calculatePositionPNL;
+function calculateUnsettledPnl(market, perpPosition, oraclePriceData) {
+    var unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
+    var unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        var fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        var maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount
+            .sub(perpPosition.quoteEntryAmount)
+            .add(fundingPnL), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateUnsettledPnl = calculateUnsettledPnl;
+/**
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // TODO-PRECISION
+ */
+function calculatePositionFundingPNL(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    var ammCumulativeFundingRate;
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+    }
+    else {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+    }
+    var perPositionFundingRate = ammCumulativeFundingRate
+        .sub(perpPosition.lastCumulativeFundingRate)
+        .mul(perpPosition.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.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.lpShares.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.quoteEntryAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(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.calculateCostBasis = calculateCostBasis;
+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

@@ -10,7 +10,7 @@ import {
 	ZERO,
 } from '../constants/numericConstants';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
 import {
 	calculateUpdatedAMM,
 	calculateUpdatedAMMSpreadReserves,
@@ -29,8 +29,8 @@ import { calculateBaseAssetValueWithOracle } from './margin';
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
 export function calculateBaseAssetValue(
-	market: MarketAccount,
-	userPosition: UserPosition,
+	market: PerpMarketAccount,
+	userPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
@@ -84,38 +84,38 @@ export function calculateBaseAssetValue(
  * calculatePositionPNL
  * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
  * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	withFunding = false,
 	oraclePriceData: OraclePriceData
 ): BN {
-	if (marketPosition.baseAssetAmount.eq(ZERO)) {
-		return marketPosition.quoteAssetAmount;
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
+		return perpPosition.quoteAssetAmount;
 	}
 
 	const baseAssetValue = calculateBaseAssetValueWithOracle(
 		market,
-		marketPosition,
+		perpPosition,
 		oraclePriceData
 	);
 
-	const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+	const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
 		? new BN(-1)
 		: new BN(1);
 	let pnl = baseAssetValue
 		.mul(baseAssetValueSign)
-		.add(marketPosition.quoteAssetAmount);
+		.add(perpPosition.quoteAssetAmount);
 
 	if (withFunding) {
 		const fundingRatePnL = calculatePositionFundingPNL(
 			market,
-			marketPosition
+			perpPosition
 		).div(PRICE_TO_QUOTE_PRECISION);
 
 		pnl = pnl.add(fundingRatePnL);
@@ -125,26 +125,26 @@ export function calculatePositionPNL(
 }
 
 export function calculateUnsettledPnl(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const unrealizedPnl = calculatePositionPNL(
 		market,
-		marketPosition,
+		perpPosition,
 		true,
 		oraclePriceData
 	);
 
 	let unsettledPnl = unrealizedPnl;
 	if (unrealizedPnl.gt(ZERO)) {
-		const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(
+		const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(
 			PRICE_TO_QUOTE_PRECISION
 		);
 
 		const maxPositivePnl = BN.max(
-			marketPosition.quoteAssetAmount
-				.sub(marketPosition.quoteEntryAmount)
+			perpPosition.quoteAssetAmount
+				.sub(perpPosition.quoteEntryAmount)
 				.add(fundingPnL),
 			ZERO
 		);
@@ -157,27 +157,27 @@ export function calculateUnsettledPnl(
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(
-	market: MarketAccount,
-	marketPosition: UserPosition
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition
 ): BN {
-	if (marketPosition.baseAssetAmount.eq(ZERO)) {
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	let ammCumulativeFundingRate: BN;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
 		ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
 	} else {
 		ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
 	}
 
 	const perPositionFundingRate = ammCumulativeFundingRate
-		.sub(marketPosition.lastCumulativeFundingRate)
-		.mul(marketPosition.baseAssetAmount)
+		.sub(perpPosition.lastCumulativeFundingRate)
+		.mul(perpPosition.baseAssetAmount)
 		.div(AMM_RESERVE_PRECISION)
 		.div(FUNDING_PAYMENT_PRECISION)
 		.mul(new BN(-1));
@@ -185,7 +185,7 @@ export function calculatePositionFundingPNL(
 	return perPositionFundingRate;
 }
 
-export function positionIsAvailable(position: UserPosition): boolean {
+export function positionIsAvailable(position: PerpPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
 		position.openOrders.eq(ZERO) &&
@@ -199,7 +199,7 @@ export function positionIsAvailable(position: UserPosition): boolean {
  * @param userPosition
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
-export function calculateEntryPrice(userPosition: UserPosition): BN {
+export function calculateEntryPrice(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
@@ -216,7 +216,7 @@ export function calculateEntryPrice(userPosition: UserPosition): BN {
  * @param userPosition
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
-export function calculateCostBasis(userPosition: UserPosition): BN {
+export function calculateCostBasis(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
@@ -229,7 +229,7 @@ export function calculateCostBasis(userPosition: UserPosition): BN {
 }
 
 export function findDirectionToClose(
-	userPosition: UserPosition
+	userPosition: PerpPosition
 ): PositionDirection {
 	return userPosition.baseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
@@ -237,14 +237,14 @@ export function findDirectionToClose(
 }
 
 export function positionCurrentDirection(
-	userPosition: UserPosition
+	userPosition: PerpPosition
 ): PositionDirection {
 	return userPosition.baseAssetAmount.gte(ZERO)
 		? PositionDirection.LONG
 		: PositionDirection.SHORT;
 }
 
-export function isEmptyPosition(userPosition: UserPosition): boolean {
+export function isEmptyPosition(userPosition: PerpPosition): boolean {
 	return (
 		userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders.eq(ZERO)
 	);