@drift-labs/sdk 2.97.0-beta.21 → 2.97.0-beta.23

package/lib/node/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/node/math/position.d.ts

@@ -0,0 +1,54 @@
+/// <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;
+/**
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+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/node/math/position.js

@@ -0,0 +1,198 @@
+"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.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 = calculatePositionFundingPNL(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;
+/**
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+function calculatePositionFundingPNL(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.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/node/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;

package/lib/node/math/repeg.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateBudgetedKBN = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("../constants/numericConstants");
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateAdjustKCost(amm, numerator, denomenator) {
+    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = amm.baseAssetReserve;
+    const y = amm.quoteAssetReserve;
+    const d = amm.baseAssetAmountWithAmm;
+    const Q = amm.pegMultiplier;
+    const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
+    const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
+    const cost = quoteScale
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(x.add(d))
+        .sub(quoteScale
+        .mul(p)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(numericConstants_1.PEG_PRECISION);
+    return cost.mul(new anchor_1.BN(-1));
+}
+exports.calculateAdjustKCost = calculateAdjustKCost;
+// /**
+//  * Helper function calculating adjust k cost
+//  * @param amm
+//  * @param numerator
+//  * @param denomenator
+//  * @returns cost : Precision QUOTE_ASSET_PRECISION
+//  */
+// export function calculateAdjustKCost2(
+// 	amm: AMM,
+// 	numerator: BN,
+// 	denomenator: BN
+// ): BN {
+// 	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+// 	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
+// 		? PositionDirection.SHORT
+// 		: PositionDirection.LONG;
+// 	const [newQuoteAssetReserve, _newBaseAssetReserve] =
+// 		calculateAmmReservesAfterSwap(
+// 			amm,
+// 			'base',
+// 			amm.baseAssetAmountWithAmm.abs(),
+// 			getSwapDirection('base', directionToClose)
+// 		);
+// }
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateRepegCost(amm, newPeg) {
+    const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+    const cost = dqar
+        .mul(newPeg.sub(amm.pegMultiplier))
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(numericConstants_1.PEG_PRECISION);
+    return cost;
+}
+exports.calculateRepegCost = calculateRepegCost;
+function calculateBudgetedKBN(x, y, budget, Q, d) {
+    (0, assert_1.assert)(Q.gt(new anchor_1.BN(0)));
+    const C = budget.mul(new anchor_1.BN(-1));
+    let dSign = new anchor_1.BN(1);
+    if (d.lt(new anchor_1.BN(0))) {
+        dSign = new anchor_1.BN(-1);
+    }
+    const pegged_y_d_d = y
+        .mul(d)
+        .mul(d)
+        .mul(Q)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION);
+    const numer1 = pegged_y_d_d;
+    const numer2 = C.mul(d)
+        .div(numericConstants_1.QUOTE_PRECISION)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .mul(dSign);
+    const denom1 = C.mul(x)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    const denom2 = pegged_y_d_d;
+    // protocol is spending to increase k
+    if (C.lt(numericConstants_1.ZERO)) {
+        // thus denom1 is negative and solution is unstable
+        if (denom1.abs().gt(denom2.abs())) {
+            console.log('denom1 > denom2', denom1.toString(), denom2.toString());
+            console.log('budget cost exceeds stable K solution');
+            return [new anchor_1.BN(10000), new anchor_1.BN(1)];
+        }
+    }
+    const numerator = numer1.sub(numer2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    const denominator = denom1.add(denom2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    return [numerator, denominator];
+}
+exports.calculateBudgetedKBN = calculateBudgetedKBN;
+function calculateBudgetedK(amm, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
+    // numer
+    //   =  y*d*d*Q - Cxd - Cdd
+    //   =  y/x*Q*d*d - Cd - Cd/x
+    //   = mark      - C/d - C/(x)
+    //   =  mark/C    - 1/d - 1/x
+    // denom
+    // = C*x*x + C*x*d + y*d*d*Q
+    // = x/d**2 + 1 / d + mark/C
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    const x = amm.baseAssetReserve;
+    const y = amm.quoteAssetReserve;
+    const d = amm.baseAssetAmountWithAmm;
+    const Q = amm.pegMultiplier;
+    const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(amm, budget, targetPrice) {
+    let perPegCost = amm.quoteAssetReserve
+        .sub(amm.terminalQuoteAssetReserve)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION.div(numericConstants_1.PRICE_PRECISION));
+    if (perPegCost.gt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.add(numericConstants_1.ONE);
+    }
+    else if (perPegCost.lt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.sub(numericConstants_1.ONE);
+    }
+    const targetPeg = targetPrice
+        .mul(amm.baseAssetReserve)
+        .div(amm.quoteAssetReserve)
+        .div(numericConstants_1.PRICE_DIV_PEG);
+    const pegChangeDirection = targetPeg.sub(amm.pegMultiplier);
+    const useTargetPeg = (perPegCost.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+        (perPegCost.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
+    if (perPegCost.eq(numericConstants_1.ZERO) || useTargetPeg) {
+        return targetPeg;
+    }
+    const budgetDeltaPeg = budget.mul(numericConstants_1.PEG_PRECISION).div(perPegCost);
+    const newPeg = anchor_1.BN.max(numericConstants_1.ONE, amm.pegMultiplier.add(budgetDeltaPeg));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;