@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.40

package/lib/math/orders.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasLimitPrice = exports.getOptionalLimitPrice = 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");
+const amm_1 = require("./amm");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
     }
-    const position = user.getUserPosition(order.marketIndex) ||
+    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)) {
@@ -37,7 +37,7 @@ function isOrderRiskIncreasingInSameDirection(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
     }
-    const position = user.getUserPosition(order.marketIndex) ||
+    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)) {
@@ -59,7 +59,7 @@ function isOrderReduceOnly(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
     }
-    const position = user.getUserPosition(order.marketIndex) ||
+    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) &&
@@ -79,27 +79,27 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
     return baseAssetAmount.sub(remainder);
 }
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, market, oraclePriceData, slot) {
+function getLimitPrice(order, oraclePriceData, slot) {
     let limitPrice;
-    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    if (order.oraclePriceOffset !== 0) {
+        limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
     }
     else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
-        if ((0, auction_1.isAuctionComplete)(order, slot)) {
+        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')) {
-            const askPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
-            const delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
-            limitPrice = askPrice.add(delta);
-        }
         else {
-            const bidPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
-            const delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
-            limitPrice = bidPrice.sub(delta);
+            // check oracle validity?
+            const oraclePrice1Pct = oraclePriceData.price.div(new anchor_1.BN(100));
+            if ((0, types_1.isVariant)(order.direction, 'long')) {
+                limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
+            }
+            else {
+                limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
+            }
         }
     }
     else {
@@ -108,3 +108,76 @@ function getLimitPrice(order, market, oraclePriceData, slot) {
     return limitPrice;
 }
 exports.getLimitPrice = getLimitPrice;
+function getOptionalLimitPrice(order, oraclePriceData, slot) {
+    if (hasLimitPrice(order, slot)) {
+        return getLimitPrice(order, oraclePriceData, slot);
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getOptionalLimitPrice = getOptionalLimitPrice;
+function hasLimitPrice(order, slot) {
+    return (order.price.gt(numericConstants_1.ZERO) ||
+        order.oraclePriceOffset != 0 ||
+        !(0, auction_1.isAuctionComplete)(order, slot));
+}
+exports.hasLimitPrice = hasLimitPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
+    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
+        isOrderExpired(order, ts));
+}
+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;
+    }
+    const limitPrice = getOptionalLimitPrice(order, oraclePriceData, slot);
+    let baseAssetAmount;
+    if (limitPrice !== undefined) {
+        baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData);
+    }
+    else {
+        baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    }
+    const 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) {
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.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) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+        !(0, types_1.isVariant)(order.status, 'open') ||
+        order.maxTs.eq(numericConstants_1.ZERO)) {
+        return false;
+    }
+    return new anchor_1.BN(ts).gt(order.maxTs);
+}
+exports.isOrderExpired = isOrderExpired;
+function isMarketOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket']);
+}
+exports.isMarketOrder = isMarketOrder;
+function isLimitOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
+}
+exports.isLimitOrder = isLimitOrder;

package/lib/math/position.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
-import { BN } from '../';
+import { BN, SpotMarketAccount } from '../';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -10,30 +10,44 @@ import { MarketAccount, PositionDirection, UserPosition } from '../types';
  * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-export declare function calculateBaseAssetValue(market: MarketAccount, userPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+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 marketPosition
+ * @param PerpPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
-export declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+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 marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-export declare function calculatePositionFundingPNL(market: MarketAccount, marketPosition: UserPosition): BN;
-export declare function positionIsAvailable(position: UserPosition): boolean;
+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: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
-export declare function calculateEntryPrice(userPosition: UserPosition): BN;
-export declare function findDirectionToClose(userPosition: UserPosition): PositionDirection;
-export declare function positionCurrentDirection(userPosition: UserPosition): PositionDirection;
-export declare function isEmptyPosition(userPosition: UserPosition): boolean;
+export declare function calculateCostBasis(userPosition: PerpPosition): BN;
+export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;
+export declare function positionCurrentDirection(userPosition: PerpPosition): PositionDirection;
+export declare function isEmptyPosition(userPosition: PerpPosition): boolean;

package/lib/math/position.js

@@ -1,10 +1,12 @@
 "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;
+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
@@ -13,23 +15,28 @@ const amm_1 = require("./amm");
  * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-function calculateBaseAssetValue(market, userPosition, oraclePriceData) {
+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 (market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
-        prepegAmm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: sqrtK,
-            pegMultiplier: newPeg,
-        };
+    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 = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+        prepegAmm = market.amm;
     }
     const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
     switch (directionToClose) {
@@ -51,75 +58,124 @@ exports.calculateBaseAssetValue = 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
  */
-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);
+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, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        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);
+    const fundingPnL = calculatePositionFundingPNL(market, perpPosition);
+    let unsettledPnl = unrealizedPnl.add(fundingPnL);
+    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)
+            .add(excessPnlPool), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateClaimablePnl = calculateClaimablePnl;
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-function calculatePositionFundingPNL(market, marketPosition) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+function calculatePositionFundingPNL(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     let ammCumulativeFundingRate;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.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(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.FUNDING_PAYMENT_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.eq(numericConstants_1.ZERO);
+    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: MARK_PRICE_PRECISION (10^10)
+ * @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.quoteAssetAmount
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+    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) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .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
@@ -133,6 +189,6 @@ function positionCurrentDirection(userPosition) {
 }
 exports.positionCurrentDirection = positionCurrentDirection;
 function isEmptyPosition(userPosition) {
-    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
+    return userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders === 0;
 }
 exports.isEmptyPosition = isEmptyPosition;

package/lib/math/repeg.js

@@ -15,16 +15,16 @@ 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.netBaseAssetAmount;
+    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.MARK_PRICE_PRECISION).div(denomenator);
+    const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
     const cost = quoteScale
         .div(x.add(d))
         .sub(quoteScale
         .mul(p)
-        .div(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(x.mul(p).div(numericConstants_1.MARK_PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(numericConstants_1.PEG_PRECISION);
     return cost.mul(new anchor_1.BN(-1));
@@ -71,6 +71,15 @@ function calculateBudgetedKBN(x, y, budget, Q, 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];
@@ -92,7 +101,7 @@ function calculateBudgetedK(amm, cost) {
     // 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.netBaseAssetAmount;
+    const d = amm.baseAssetAmountWithAmm;
     const Q = amm.pegMultiplier;
     const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
     return [numerator, denominator];
@@ -111,7 +120,7 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     const k = amm.sqrtK.mul(amm.sqrtK);
     const x = amm.baseAssetReserve;
     const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
+    const d = amm.baseAssetAmountWithAmm;
     const Q = amm.pegMultiplier;
     const C = cost.mul(new anchor_1.BN(-1));
     const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
@@ -121,8 +130,8 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     if (deltaQuoteAssetReserves.eq(numericConstants_1.ZERO) || useTargetPeg) {
         return targetPeg;
     }
-    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    const deltaPegMultiplier = C.mul(numericConstants_1.PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
+    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.PRICE_PRECISION));
     return newPeg;
 }
 exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/spotBalance.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+export declare function getBalance(tokenAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getTokenAmount(balanceAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotBalanceType): BN;
+export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateUtilization(bank: SpotMarketAccount): BN;
+export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
+export declare function calculateDepositRate(bank: SpotMarketAccount): BN;
+export declare function calculateBorrowRate(bank: SpotMarketAccount): BN;
+export declare function calculateInterestAccumulated(bank: SpotMarketAccount, now: BN): {
+    borrowInterest: BN;
+    depositInterest: BN;
+};
+export declare function calculateWithdrawLimit(spotMarket: SpotMarketAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: BN;
+};