@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/browser/math/orders.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTakingOrder = exports.isRestingLimitOrder = exports.isTriggered = exports.mustBeTriggered = exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasAuctionPrice = exports.hasLimitPrice = exports.getLimitPrice = exports.standardizePrice = 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("@coral-xyz/anchor");
+const auction_1 = require("./auction");
+const amm_1 = require("./amm");
+function isOrderRiskIncreasing(user, order) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getPerpPosition(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;
+    }
+    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 ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getPerpPosition(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;
+    }
+    const position = user.getPerpPosition(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) {
+    const remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function standardizePrice(price, tickSize, direction) {
+    if (price.eq(numericConstants_1.ZERO)) {
+        console.log('price is zero');
+        return price;
+    }
+    const remainder = price.mod(tickSize);
+    if (remainder.eq(numericConstants_1.ZERO)) {
+        return price;
+    }
+    if ((0, types_1.isVariant)(direction, 'long')) {
+        return price.sub(remainder);
+    }
+    else {
+        return price.add(tickSize).sub(remainder);
+    }
+}
+exports.standardizePrice = standardizePrice;
+function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
+    let limitPrice;
+    if (hasAuctionPrice(order, slot)) {
+        limitPrice = (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
+    }
+    else if (order.oraclePriceOffset !== 0) {
+        limitPrice = anchor_1.BN.max(oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset)), numericConstants_1.ONE);
+    }
+    else if (order.price.eq(numericConstants_1.ZERO)) {
+        limitPrice = fallbackPrice;
+    }
+    else {
+        limitPrice = order.price;
+    }
+    return limitPrice;
+}
+exports.getLimitPrice = getLimitPrice;
+function hasLimitPrice(order, slot) {
+    return (order.price.gt(numericConstants_1.ZERO) ||
+        order.oraclePriceOffset != 0 ||
+        !(0, auction_1.isAuctionComplete)(order, slot));
+}
+exports.hasLimitPrice = hasLimitPrice;
+function hasAuctionPrice(order, slot) {
+    return (!(0, auction_1.isAuctionComplete)(order, slot) &&
+        (!order.auctionStartPrice.eq(numericConstants_1.ZERO) || !order.auctionEndPrice.eq(numericConstants_1.ZERO)));
+}
+exports.hasAuctionPrice = hasAuctionPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot, ts, minAuctionDuration) {
+    return (((0, auction_1.isFallbackAvailableLiquiditySource)(order, minAuctionDuration, slot) &&
+        calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).gte(market.amm.minOrderSize)) ||
+        isOrderExpired(order, ts));
+}
+exports.isFillableByVAMM = isFillableByVAMM;
+function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
+    if (mustBeTriggered(order) && !isTriggered(order)) {
+        return numericConstants_1.ZERO;
+    }
+    const limitPrice = getLimitPrice(order, oraclePriceData, slot);
+    let baseAssetAmount;
+    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    if (limitPrice !== undefined) {
+        baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, limitPrice, oraclePriceData);
+    }
+    else {
+        baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    }
+    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, order.direction);
+    return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, oraclePriceData) {
+    const adjustedLimitPrice = (0, types_1.isVariant)(order.direction, 'long')
+        ? limitPrice.sub(amm.orderTickSize)
+        : limitPrice.add(amm.orderTickSize);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, adjustedLimitPrice, order.direction, oraclePriceData);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, amm.orderStepSize);
+    // Check that directions are the same
+    const sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    const baseAssetAmountUnfilled = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    return baseAssetAmount.gt(baseAssetAmountUnfilled)
+        ? baseAssetAmountUnfilled
+        : 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, ts, enforceBuffer = false, bufferSeconds = 15) {
+    if (mustBeTriggered(order) ||
+        !(0, types_1.isVariant)(order.status, 'open') ||
+        order.maxTs.eq(numericConstants_1.ZERO)) {
+        return false;
+    }
+    let maxTs;
+    if (enforceBuffer && isLimitOrder(order)) {
+        maxTs = order.maxTs.addn(bufferSeconds);
+    }
+    else {
+        maxTs = order.maxTs;
+    }
+    return new anchor_1.BN(ts).gt(maxTs);
+}
+exports.isOrderExpired = isOrderExpired;
+function isMarketOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle']);
+}
+exports.isMarketOrder = isMarketOrder;
+function isLimitOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
+}
+exports.isLimitOrder = isLimitOrder;
+function mustBeTriggered(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']);
+}
+exports.mustBeTriggered = mustBeTriggered;
+function isTriggered(order) {
+    return (0, types_1.isOneOfVariant)(order.triggerCondition, [
+        'triggeredAbove',
+        'triggeredBelow',
+    ]);
+}
+exports.isTriggered = isTriggered;
+function isRestingLimitOrder(order, slot) {
+    if (!isLimitOrder(order)) {
+        return false;
+    }
+    return order.postOnly || (0, auction_1.isAuctionComplete)(order, slot);
+}
+exports.isRestingLimitOrder = isRestingLimitOrder;
+function isTakingOrder(order, slot) {
+    return isMarketOrder(order) || !isRestingLimitOrder(order, slot);
+}
+exports.isTakingOrder = isTakingOrder;

package/lib/browser/math/position.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="bn.js" />
+import { BN, SpotMarketAccount } from '../';
+import { OraclePriceData } from '../oracles/types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
+/**
+ * calculateBaseAssetValue
+ * = market value of closing entire position
+ * @param market
+ * @param userPosition
+ * @param oraclePriceData
+ * @returns Base Asset Value. : Precision QUOTE_PRECISION
+ */
+export declare function calculateBaseAssetValue(market: PerpMarketAccount, userPosition: PerpPosition, oraclePriceData: OraclePriceData, useSpread?: boolean, skipUpdate?: boolean): BN;
+/**
+ * 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
+ */
+export declare function calculatePositionPNL(market: PerpMarketAccount, perpPosition: PerpPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculateClaimablePnl(market: PerpMarketAccount, spotMarket: SpotMarketAccount, perpPosition: PerpPosition, oraclePriceData: OraclePriceData): BN;
+/**
+ * Returns total fees and funding pnl for a position
+ *
+ * @param market
+ * @param PerpPosition
+ * @param includeUnsettled include unsettled funding in return value (default: true)
+ * @returns — // QUOTE_PRECISION
+ */
+export declare function calculateFeesAndFundingPnl(market: PerpMarketAccount, perpPosition: PerpPosition, includeUnsettled?: boolean): BN;
+/**
+ * Returns unsettled funding pnl for the position
+ *
+ * To calculate all fees and funding pnl including settled, use calculateFeesAndFundingPnl
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+export declare function calculateUnsettledFundingPnl(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
+/**
+ * @deprecated use calculateUnsettledFundingPnl or calculateFeesAndFundingPnl instead
+ */
+export declare function calculatePositionFundingPNL(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
+export declare function positionIsAvailable(position: PerpPosition): boolean;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export declare function calculateBreakEvenPrice(userPosition: PerpPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export declare function calculateEntryPrice(userPosition: PerpPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+export declare function calculateCostBasis(userPosition: PerpPosition, includeSettledPnl?: boolean): BN;
+export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;
+export declare function positionCurrentDirection(userPosition: PerpPosition): PositionDirection;
+export declare function isEmptyPosition(userPosition: PerpPosition): boolean;
+export declare function hasOpenOrders(position: PerpPosition): boolean;

package/lib/browser/math/position.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOpenOrders = exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.calculateBreakEvenPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledFundingPnl = exports.calculateFeesAndFundingPnl = exports.calculateClaimablePnl = 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");
+const margin_1 = require("./margin");
+const market_1 = require("./market");
+/**
+ * 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, useSpread = true, skipUpdate = false) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const directionToClose = findDirectionToClose(userPosition);
+    let prepegAmm;
+    if (!skipUpdate) {
+        if (market.amm.baseSpread > 0 && useSpread) {
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
+            prepegAmm = {
+                baseAssetReserve,
+                quoteAssetReserve,
+                sqrtK: sqrtK,
+                pegMultiplier: newPeg,
+            };
+        }
+        else {
+            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+        }
+    }
+    else {
+        prepegAmm = market.amm;
+    }
+    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, 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 PerpPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+function calculatePositionPNL(market, perpPosition, withFunding = false, oraclePriceData) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return perpPosition.quoteAssetAmount;
+    }
+    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    let pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(perpPosition.quoteAssetAmount);
+    if (withFunding) {
+        const fundingRatePnL = calculateUnsettledFundingPnl(market, perpPosition);
+        pnl = pnl.add(fundingRatePnL);
+    }
+    return pnl;
+}
+exports.calculatePositionPNL = calculatePositionPNL;
+function calculateClaimablePnl(market, spotMarket, perpPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
+    let unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, (0, market_1.calculateNetUserPnlImbalance)(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
+        const maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount.sub(perpPosition.quoteEntryAmount), numericConstants_1.ZERO).add(excessPnlPool);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateClaimablePnl = calculateClaimablePnl;
+/**
+ * Returns total fees and funding pnl for a position
+ *
+ * @param market
+ * @param PerpPosition
+ * @param includeUnsettled include unsettled funding in return value (default: true)
+ * @returns — // QUOTE_PRECISION
+ */
+function calculateFeesAndFundingPnl(market, perpPosition, includeUnsettled = true) {
+    const settledFundingAndFeesPnl = perpPosition.quoteBreakEvenAmount.sub(perpPosition.quoteEntryAmount);
+    if (!includeUnsettled) {
+        return settledFundingAndFeesPnl;
+    }
+    const unsettledFundingPnl = calculateUnsettledFundingPnl(market, perpPosition);
+    return settledFundingAndFeesPnl.add(unsettledFundingPnl);
+}
+exports.calculateFeesAndFundingPnl = calculateFeesAndFundingPnl;
+/**
+ * Returns unsettled funding pnl for the position
+ *
+ * To calculate all fees and funding pnl including settled, use calculateFeesAndFundingPnl
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+function calculateUnsettledFundingPnl(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    let ammCumulativeFundingRate;
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+    }
+    else {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+    }
+    const perPositionFundingRate = ammCumulativeFundingRate
+        .sub(perpPosition.lastCumulativeFundingRate)
+        .mul(perpPosition.baseAssetAmount)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.FUNDING_RATE_BUFFER_PRECISION)
+        .mul(new __1.BN(-1));
+    return perPositionFundingRate;
+}
+exports.calculateUnsettledFundingPnl = calculateUnsettledFundingPnl;
+/**
+ * @deprecated use calculateUnsettledFundingPnl or calculateFeesAndFundingPnl instead
+ */
+function calculatePositionFundingPNL(market, perpPosition) {
+    return calculateUnsettledFundingPnl(market, perpPosition);
+}
+exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
+function positionIsAvailable(position) {
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders === 0 &&
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.lpShares.eq(numericConstants_1.ZERO));
+}
+exports.positionIsAvailable = positionIsAvailable;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+function calculateBreakEvenPrice(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteBreakEvenAmount
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateBreakEvenPrice = calculateBreakEvenPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+function calculateEntryPrice(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteEntryAmount
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(userPosition, includeSettledPnl = false) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .add(includeSettledPnl ? userPosition.settledPnl : numericConstants_1.ZERO)
+        .mul(numericConstants_1.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 === 0;
+}
+exports.isEmptyPosition = isEmptyPosition;
+function hasOpenOrders(position) {
+    return (position.openOrders != 0 ||
+        !position.openBids.eq(numericConstants_1.ZERO) ||
+        !position.openAsks.eq(numericConstants_1.ZERO));
+}
+exports.hasOpenOrders = hasOpenOrders;

package/lib/browser/math/repeg.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { AMM } from '../types';
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateAdjustKCost(amm: AMM, numerator: BN, denomenator: BN): BN;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateRepegCost(amm: AMM, newPeg: BN): BN;
+export declare function calculateBudgetedKBN(x: BN, y: BN, budget: BN, Q: BN, d: BN): [BN, BN];
+export declare function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN];
+export declare function calculateBudgetedPeg(amm: AMM, budget: BN, targetPrice: BN): BN;