@drift-labs/sdk 0.2.0-master.0 → 0.2.0-master.11

package/src/math/funding.js

@@ -0,0 +1,248 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFundingPool = exports.calculateLongShortFundingRateAndLiveTwaps = exports.calculateLongShortFundingRate = exports.calculateEstimatedFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const market_1 = require("./market");
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // periodAdjustment
+        // 	1: hourly
+        //  24: daily
+        //  24 * 365.25: annualized
+        const secondsInHour = new anchor_1.BN(3600);
+        const hoursInDay = new anchor_1.BN(24);
+        const ONE = new anchor_1.BN(1);
+        if (!market.initialized) {
+            return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const payFreq = new anchor_1.BN(market.amm.fundingPeriod);
+        // todo: sufficiently differs from blockchain timestamp?
+        const now = new anchor_1.BN((Date.now() / 1000).toFixed(0));
+        const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
+        // calculate real-time mark twap
+        const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
+        const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
+        const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
+        const markTwapTimeSinceLastUpdate = anchor_1.BN.max(secondsInHour, anchor_1.BN.max(numericConstants_1.ZERO, secondsInHour.sub(timeSinceLastMarkChange)));
+        const baseAssetPriceWithMantissa = market_1.calculateMarkPrice(market, oraclePriceData);
+        const markTwapWithMantissa = markTwapTimeSinceLastUpdate
+            .mul(lastMarkTwapWithMantissa)
+            .add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))
+            .div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
+        // calculate real-time (predicted) oracle twap
+        // note: oracle twap depends on `when the chord is struck` (market is trade)
+        const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
+        const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+        const oracleInvalidDuration = anchor_1.BN.max(numericConstants_1.ZERO, lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs));
+        const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
+        const oracleTwapTimeSinceLastUpdate = anchor_1.BN.max(ONE, anchor_1.BN.min(secondsInHour, anchor_1.BN.max(ONE, secondsInHour.sub(timeSinceLastOracleTwapUpdate))));
+        let oracleTwapWithMantissa = lastOracleTwapWithMantissa;
+        // if passing live oracle data, improve predicted calc estimate
+        if (oraclePriceData) {
+            const oraclePrice = oraclePriceData.price;
+            const oracleLiveVsTwap = oraclePrice
+                .sub(lastOracleTwapWithMantissa)
+                .abs()
+                .mul(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(lastOracleTwapWithMantissa);
+            // verify pyth live input is within 10% of last twap for live update
+            if (oracleLiveVsTwap.lte(numericConstants_1.MARK_PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
+                oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
+                    .mul(lastOracleTwapWithMantissa)
+                    .add(timeSinceLastMarkChange.mul(oraclePrice))
+                    .div(timeSinceLastMarkChange.add(oracleTwapTimeSinceLastUpdate));
+            }
+        }
+        const shrunkLastOracleTwapwithMantissa = oracleTwapTimeSinceLastUpdate
+            .mul(lastOracleTwapWithMantissa)
+            .add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
+            .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
+        const twapSpread = lastMarkTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
+        const twapSpreadPct = twapSpread
+            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(new anchor_1.BN(100))
+            .div(shrunkLastOracleTwapwithMantissa);
+        const lowerboundEst = twapSpreadPct
+            .mul(payFreq)
+            .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
+            .mul(periodAdjustment)
+            .div(secondsInHour)
+            .div(secondsInHour)
+            .div(hoursInDay);
+        const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+        const interpRateQuote = twapSpreadPct
+            .mul(periodAdjustment)
+            .div(hoursInDay)
+            .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
+        let feePoolSize = calculateFundingPool(market);
+        if (interpRateQuote.lt(new anchor_1.BN(0))) {
+            feePoolSize = feePoolSize.mul(new anchor_1.BN(-1));
+        }
+        let cappedAltEst;
+        let largerSide;
+        let smallerSide;
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+            largerSide = market.baseAssetAmountLong.abs();
+            smallerSide = market.baseAssetAmountShort.abs();
+            if (twapSpread.gt(new anchor_1.BN(0))) {
+                return [
+                    markTwapWithMantissa,
+                    oracleTwapWithMantissa,
+                    lowerboundEst,
+                    interpEst,
+                    interpEst,
+                ];
+            }
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+            largerSide = market.baseAssetAmountShort.abs();
+            smallerSide = market.baseAssetAmountLong.abs();
+            if (twapSpread.lt(new anchor_1.BN(0))) {
+                return [
+                    markTwapWithMantissa,
+                    oracleTwapWithMantissa,
+                    lowerboundEst,
+                    interpEst,
+                    interpEst,
+                ];
+            }
+        }
+        else {
+            return [
+                markTwapWithMantissa,
+                oracleTwapWithMantissa,
+                lowerboundEst,
+                interpEst,
+                interpEst,
+            ];
+        }
+        if (largerSide.gt(numericConstants_1.ZERO)) {
+            // funding smaller flow
+            cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
+            const feePoolTopOff = feePoolSize
+                .mul(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION);
+            cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
+            cappedAltEst = cappedAltEst
+                .mul(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(oracleTwapWithMantissa)
+                .mul(periodAdjustment);
+            if (cappedAltEst.abs().gte(interpEst.abs())) {
+                cappedAltEst = interpEst;
+            }
+        }
+        else {
+            cappedAltEst = interpEst;
+        }
+        return [
+            markTwapWithMantissa,
+            oracleTwapWithMantissa,
+            lowerboundEst,
+            cappedAltEst,
+            interpEst,
+        ];
+    });
+}
+exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1), estimationMethod) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_1, _2, lowerboundEst, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (estimationMethod == 'lowerbound') {
+            //assuming remaining funding period has no gap
+            return lowerboundEst;
+        }
+        else if (estimationMethod == 'capped') {
+            return cappedAltEst;
+        }
+        else {
+            return interpEst;
+        }
+    });
+}
+exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_1, _2, _, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+            return [cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+            return [interpEst, cappedAltEst];
+        }
+        else {
+            return [interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+            return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+            return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
+        }
+        else {
+            return [markTwapLive, oracleTwapLive, interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRateAndLiveTwaps = calculateLongShortFundingRateAndLiveTwaps;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+function calculateFundingPool(market) {
+    // todo
+    const totalFeeLB = market.amm.totalExchangeFee.div(new anchor_1.BN(2));
+    const feePool = anchor_1.BN.max(numericConstants_1.ZERO, market.amm.totalFeeMinusDistributions
+        .sub(totalFeeLB)
+        .mul(new anchor_1.BN(1))
+        .div(new anchor_1.BN(3)));
+    return feePool;
+}
+exports.calculateFundingPool = calculateFundingPool;

package/src/math/market.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+const types_1 = require("../types");
+const amm_1 = require("./amm");
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateMarkPrice(market, oraclePriceData) {
+    const newAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
+    return amm_1.calculatePrice(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
+}
+exports.calculateMarkPrice = calculateMarkPrice;
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateBidPrice(market, oraclePriceData) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
+    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateBidPrice = calculateBidPrice;
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateAskPrice(market, oraclePriceData) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
+    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateAskPrice = calculateAskPrice;
+function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', baseAssetAmount.abs(), amm_1.getSwapDirection('base', direction));
+    const newAmm = Object.assign({}, market.amm);
+    const newMarket = Object.assign({}, market);
+    newMarket.amm = newAmm;
+    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+    return newMarket;
+}
+exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
+function calculateMarkOracleSpread(market, oraclePriceData) {
+    const markPrice = calculateMarkPrice(market, oraclePriceData);
+    return calculateOracleSpread(markPrice, oraclePriceData);
+}
+exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
+function calculateOracleSpread(price, oraclePriceData) {
+    return price.sub(oraclePriceData.price);
+}
+exports.calculateOracleSpread = calculateOracleSpread;

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,9 +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 } from './auction';
+import { getAuctionPrice, isAuctionComplete } from './auction';
+import { calculateAskPrice, calculateBidPrice } from './market';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -120,24 +121,27 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
+	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
 	let limitPrice;
 	if (!order.oraclePriceOffset.eq(ZERO)) {
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
+		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 {
-			limitPrice = floatingPrice;
+			const bidPrice = calculateBidPrice(market, oraclePriceData);
+			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = bidPrice.sub(delta);
 		}
-	} else if (
-		isVariant(order.orderType, 'market') ||
-		isVariant(order.orderType, 'triggerMarket')
-	) {
-		limitPrice = getAuctionPrice(order, slot);
 	} else {
 		limitPrice = order.price;
 	}

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

@@ -153,7 +153,11 @@ export function calculatePositionFundingPNL(
 }
 
 export function positionIsAvailable(position: UserPosition): boolean {
-	return position.baseAssetAmount.eq(ZERO) && position.openOrders.eq(ZERO);
+	return (
+		position.baseAssetAmount.eq(ZERO) &&
+		position.openOrders.eq(ZERO) &&
+		position.unsettledPnl.eq(ZERO)
+	);
 }
 
 /**