@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.2

package/lib/math/amm.js

@@ -1,29 +1,143 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateQuoteAssetAmountSwapped = exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
+exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
-const position_1 = require("./position");
 const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 const __1 = require("..");
+const repeg_1 = require("./repeg");
+function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
+    return targetPrice
+        .mul(baseAssetReserve)
+        .div(quoteAssetReserve)
+        .add(numericConstants_1.PRICE_DIV_PEG.div(new anchor_1.BN(2)))
+        .div(numericConstants_1.PRICE_DIV_PEG);
+}
+exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
+function calculateOptimalPegAndBudget(amm, oraclePriceData) {
+    const markPriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    const targetPrice = oraclePriceData.price;
+    const newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
+    const prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
+    const totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
+    const budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
+    if (budget.lt(prePegCost)) {
+        const maxPriceSpread = new anchor_1.BN(amm.maxSpread)
+            .mul(targetPrice)
+            .div(numericConstants_1.BID_ASK_SPREAD_PRECISION);
+        let newTargetPrice;
+        let newOptimalPeg;
+        let newBudget;
+        const targetPriceGap = markPriceBefore.sub(targetPrice);
+        if (targetPriceGap.abs().gt(maxPriceSpread)) {
+            const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
+            if (targetPriceGap.lt(new anchor_1.BN(0))) {
+                newTargetPrice = markPriceBefore.add(markAdj);
+            }
+            else {
+                newTargetPrice = markPriceBefore.sub(markAdj);
+            }
+            newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
+            newBudget = (0, repeg_1.calculateRepegCost)(amm, newOptimalPeg);
+            return [newTargetPrice, newOptimalPeg, newBudget, false];
+        }
+    }
+    return [targetPrice, newPeg, budget, true];
+}
+exports.calculateOptimalPegAndBudget = calculateOptimalPegAndBudget;
+function calculateNewAmm(amm, oraclePriceData) {
+    let pKNumer = new anchor_1.BN(1);
+    let pKDenom = new anchor_1.BN(1);
+    const [targetPrice, _newPeg, budget, checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
+    let prePegCost = (0, repeg_1.calculateRepegCost)(amm, _newPeg);
+    let newPeg = _newPeg;
+    if (prePegCost.gt(budget) && checkLowerBound) {
+        [pKNumer, pKDenom] = [new anchor_1.BN(999), new anchor_1.BN(1000)];
+        const deficitMadeup = (0, repeg_1.calculateAdjustKCost)(amm, pKNumer, pKDenom);
+        (0, assert_1.assert)(deficitMadeup.lte(new anchor_1.BN(0)));
+        prePegCost = budget.add(deficitMadeup.abs());
+        const newAmm = Object.assign({}, amm);
+        newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
+        newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
+        const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
+        newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
+        const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+            ? types_1.PositionDirection.SHORT
+            : types_1.PositionDirection.LONG;
+        const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+        newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
+        newPeg = (0, repeg_1.calculateBudgetedPeg)(newAmm, prePegCost, targetPrice);
+        prePegCost = (0, repeg_1.calculateRepegCost)(newAmm, newPeg);
+    }
+    return [prePegCost, pKNumer, pKDenom, newPeg];
+}
+exports.calculateNewAmm = calculateNewAmm;
+function calculateUpdatedAMM(amm, oraclePriceData) {
+    if (amm.curveUpdateIntensity == 0) {
+        return amm;
+    }
+    const newAmm = Object.assign({}, amm);
+    const [prepegCost, pKNumer, pKDenom, newPeg] = calculateNewAmm(amm, oraclePriceData);
+    newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
+    newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
+    const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
+    newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
+    newAmm.pegMultiplier = newPeg;
+    const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.SHORT
+        : types_1.PositionDirection.LONG;
+    const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+    newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
+    newAmm.totalFeeMinusDistributions =
+        newAmm.totalFeeMinusDistributions.sub(prepegCost);
+    return newAmm;
+}
+exports.calculateUpdatedAMM = calculateUpdatedAMM;
+function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
+    const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+    const dirReserves = calculateSpreadReserves(newAmm, direction, oraclePriceData);
+    const result = {
+        baseAssetReserve: dirReserves.baseAssetReserve,
+        quoteAssetReserve: dirReserves.quoteAssetReserve,
+        sqrtK: newAmm.sqrtK,
+        newPeg: newAmm.pegMultiplier,
+    };
+    return result;
+}
+exports.calculateUpdatedAMMSpreadReserves = calculateUpdatedAMMSpreadReserves;
+function calculateBidAskPrice(amm, oraclePriceData, withUpdate = true) {
+    let newAmm;
+    if (withUpdate) {
+        newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+    }
+    else {
+        newAmm = amm;
+    }
+    const askReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.LONG, oraclePriceData);
+    const bidReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.SHORT, oraclePriceData);
+    const askPrice = calculatePrice(askReserves.baseAssetReserve, askReserves.quoteAssetReserve, newAmm.pegMultiplier);
+    const bidPrice = calculatePrice(bidReserves.baseAssetReserve, bidReserves.quoteAssetReserve, newAmm.pegMultiplier);
+    return [bidPrice, askPrice];
+}
+exports.calculateBidAskPrice = calculateBidAskPrice;
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
  *
- * @param baseAssetAmount
- * @param quoteAssetAmount
- * @param peg_multiplier
+ * @param baseAssetReserves
+ * @param quoteAssetReserves
+ * @param pegMultiplier
  * @returns price : Precision MARK_PRICE_PRECISION
  */
-function calculatePrice(baseAssetAmount, quoteAssetAmount, peg_multiplier) {
-    if (baseAssetAmount.abs().lte(numericConstants_1.ZERO)) {
+function calculatePrice(baseAssetReserves, quoteAssetReserves, pegMultiplier) {
+    if (baseAssetReserves.abs().lte(numericConstants_1.ZERO)) {
         return new anchor_1.BN(0);
     }
-    return quoteAssetAmount
+    return quoteAssetReserves
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(peg_multiplier)
+        .mul(pegMultiplier)
         .div(numericConstants_1.PEG_PRECISION)
-        .div(baseAssetAmount);
+        .div(baseAssetReserves);
 }
 exports.calculatePrice = calculatePrice;
 /**
@@ -51,27 +165,129 @@ function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDire
     return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
-function calculateSpread(amm, direction) {
-    let spread;
-    // future logic
-    if ((0, types_1.isVariant)(direction, 'long')) {
-        spread = amm.baseSpread;
+function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+    // inventory skew
+    const netBaseAssetValue = quoteAssetReserve
+        .sub(terminalQuoteAssetReserve)
+        .mul(pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    const localBaseAssetValue = netBaseAssetAmount
+        .mul(markPrice)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+    const effectiveLeverage = localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
+        (Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
+        1 / numericConstants_1.QUOTE_PRECISION.toNumber();
+    return effectiveLeverage;
+}
+exports.calculateEffectiveLeverage = calculateEffectiveLeverage;
+function calculateMaxSpread(marginRatioInitial) {
+    const maxTargetSpread = new anchor_1.BN(marginRatioInitial)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(numericConstants_1.MARGIN_PRECISION))
+        .toNumber();
+    return maxTargetSpread;
+}
+exports.calculateMaxSpread = calculateMaxSpread;
+function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+    let longSpread = baseSpread / 2;
+    let shortSpread = baseSpread / 2;
+    if (lastOracleMarkSpreadPct.gt(numericConstants_1.ZERO)) {
+        shortSpread = Math.max(shortSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
+    }
+    else if (lastOracleMarkSpreadPct.lt(numericConstants_1.ZERO)) {
+        longSpread = Math.max(longSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
+    }
+    const maxTargetSpread = maxSpread;
+    const MAX_INVENTORY_SKEW = 5;
+    const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions);
+    if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
+        const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+            longSpread *= spreadScale;
+        }
+        else {
+            shortSpread *= spreadScale;
+        }
     }
     else {
-        spread = amm.baseSpread;
+        longSpread *= MAX_INVENTORY_SKEW;
+        shortSpread *= MAX_INVENTORY_SKEW;
+    }
+    const totalSpread = longSpread + shortSpread;
+    if (totalSpread > maxTargetSpread) {
+        if (longSpread > shortSpread) {
+            longSpread = Math.min(longSpread, maxTargetSpread);
+            shortSpread = maxTargetSpread - longSpread;
+        }
+        else {
+            shortSpread = Math.min(shortSpread, maxTargetSpread);
+            longSpread = maxTargetSpread - shortSpread;
+        }
+    }
+    return [longSpread, shortSpread];
+}
+exports.calculateSpreadBN = calculateSpreadBN;
+function calculateSpread(amm, direction, oraclePriceData) {
+    let spread = amm.baseSpread / 2;
+    if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
+        return spread;
+    }
+    const markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
+    const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
+    const targetMarkSpreadPct = markPrice
+        .sub(targetPrice)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(markPrice);
+    const confIntervalPct = confInterval
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(markPrice);
+    // oracle retreat
+    if (((0, types_1.isVariant)(direction, 'long') && targetMarkSpreadPct.lt(numericConstants_1.ZERO)) ||
+        ((0, types_1.isVariant)(direction, 'short') && targetMarkSpreadPct.gt(numericConstants_1.ZERO))) {
+        spread = Math.max(spread, targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber());
+    }
+    // inventory skew
+    const MAX_INVENTORY_SKEW = 5;
+    if ((amm.netBaseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(direction, 'long')) ||
+        (amm.netBaseAssetAmount.lt(numericConstants_1.ZERO) && (0, types_1.isVariant)(direction, 'short')) ||
+        amm.totalFeeMinusDistributions.eq(numericConstants_1.ZERO)) {
+        const netCostBasis = amm.quoteAssetAmountLong.sub(amm.quoteAssetAmountShort);
+        const netBaseAssetValue = amm.quoteAssetReserve
+            .sub(amm.terminalQuoteAssetReserve)
+            .mul(amm.pegMultiplier)
+            .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+        const localBaseAssetValue = amm.netBaseAssetAmount
+            .mul(markPrice)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+        const netPnl = netBaseAssetValue.sub(netCostBasis);
+        const localPnl = localBaseAssetValue.sub(netCostBasis);
+        let effectiveLeverage = MAX_INVENTORY_SKEW;
+        if (amm.totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
+            effectiveLeverage =
+                localPnl.sub(netPnl).toNumber() /
+                    (amm.totalFeeMinusDistributions.toNumber() + 1);
+        }
+        let spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        const maxTargetSpread = numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber() / 50; // 2%
+        // cap the scale to attempt to only scale up to maxTargetSpread
+        // always let the oracle retreat methods go through 100%
+        if (spreadScale * spread > maxTargetSpread) {
+            spreadScale = Math.max(1.05, maxTargetSpread / spread);
+        }
+        spread *= spreadScale;
     }
     return spread;
 }
 exports.calculateSpread = calculateSpread;
-function calculateSpreadReserves(amm, direction) {
-    const spread = calculateSpread(amm, direction);
+function calculateSpreadReserves(amm, direction, oraclePriceData) {
+    const spread = calculateSpread(amm, direction, oraclePriceData);
     if (spread === 0) {
         return {
             baseAssetReserve: amm.baseAssetReserve,
             quoteAssetReserve: amm.quoteAssetReserve,
         };
     }
-    const quoteAsserReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 4)));
+    const quoteAsserReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
     let quoteAssetReserve;
     if ((0, types_1.isVariant)(direction, 'long')) {
         quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
@@ -123,92 +339,6 @@ function getSwapDirection(inputAssetType, positionDirection) {
     return types_1.SwapDirection.ADD;
 }
 exports.getSwapDirection = getSwapDirection;
-/**
- * Helper function calculating adjust k cost
- * @param market
- * @param marketIndex
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
-    const netUserPosition = {
-        baseAssetAmount: market.baseAssetAmount,
-        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-        marketIndex: new anchor_1.BN(marketIndex),
-        quoteAssetAmount: new anchor_1.BN(0),
-        openOrders: new anchor_1.BN(0),
-    };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
-    const marketNewK = Object.assign({}, market);
-    marketNewK.amm = Object.assign({}, market.amm);
-    marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
-        .mul(numerator)
-        .div(denomenator);
-    marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
-        .mul(numerator)
-        .div(denomenator);
-    marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
-    netUserPosition.quoteAssetAmount = currentValue;
-    const cost = (0, __1.calculatePositionPNL)(marketNewK, netUserPosition);
-    const p = numericConstants_1.PEG_PRECISION.mul(numerator).div(denomenator);
-    const x = market.amm.baseAssetReserve;
-    const y = market.amm.quoteAssetReserve;
-    const delta = market.baseAssetAmount;
-    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const numer1 = numericConstants_1.PEG_PRECISION.sub(p).mul(y).div(numericConstants_1.PEG_PRECISION);
-    const numer20 = k
-        .mul(p)
-        .mul(p)
-        .div(numericConstants_1.PEG_PRECISION)
-        .div(numericConstants_1.PEG_PRECISION)
-        .div(x.mul(p).div(numericConstants_1.PEG_PRECISION).add(delta));
-    const numer21 = k.div(x.add(delta));
-    const formulaCost = numer21
-        .sub(numer20)
-        .sub(numer1)
-        .mul(market.amm.pegMultiplier)
-        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    console.log((0, __1.convertToNumber)(formulaCost, numericConstants_1.QUOTE_PRECISION));
-    // p.div(p.mul(x).add(delta)).sub()
-    return cost;
-}
-exports.calculateAdjustKCost = calculateAdjustKCost;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateRepegCost(market, marketIndex, newPeg) {
-    const netUserPosition = {
-        baseAssetAmount: market.baseAssetAmount,
-        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-        marketIndex: new anchor_1.BN(marketIndex),
-        quoteAssetAmount: new anchor_1.BN(0),
-        openOrders: new anchor_1.BN(0),
-    };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
-    netUserPosition.quoteAssetAmount = currentValue;
-    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
-    const marketNewPeg = Object.assign({}, market);
-    marketNewPeg.amm = Object.assign({}, market.amm);
-    // const marketNewPeg = JSON.parse(JSON.stringify(market));
-    marketNewPeg.amm.pegMultiplier = newPeg;
-    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
-    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
-    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const newQuoteAssetReserve = k.div(market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount));
-    const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(market.amm.quoteAssetReserve);
-    const cost2 = deltaQuoteAssetReserves
-        .mul(market.amm.pegMultiplier.sub(newPeg))
-        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    console.log((0, __1.convertToNumber)(cost2, numericConstants_1.QUOTE_PRECISION));
-    return cost;
-}
-exports.calculateRepegCost = calculateRepegCost;
 /**
  * Helper function calculating terminal price of amm
  *
@@ -216,10 +346,10 @@ exports.calculateRepegCost = calculateRepegCost;
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
 function calculateTerminalPrice(market) {
-    const directionToClose = market.baseAssetAmount.gt(numericConstants_1.ZERO)
+    const directionToClose = market.amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT
         : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.baseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+    const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
     const terminalPrice = newQuoteAssetReserve
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .mul(market.amm.pegMultiplier)
@@ -228,7 +358,7 @@ function calculateTerminalPrice(market) {
     return terminalPrice;
 }
 exports.calculateTerminalPrice = calculateTerminalPrice;
-function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, useSpread) {
+function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oraclePriceData) {
     const invariant = amm.sqrtK.mul(amm.sqrtK);
     const newBaseAssetReserveSquared = invariant
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
@@ -236,13 +366,7 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, useSpre
         .div(limit_price)
         .div(numericConstants_1.PEG_PRECISION);
     const newBaseAssetReserve = (0, __1.squareRootBN)(newBaseAssetReserveSquared);
-    let baseAssetReserveBefore;
-    if (useSpread) {
-        baseAssetReserveBefore = calculateSpreadReserves(amm, direction).baseAssetReserve;
-    }
-    else {
-        baseAssetReserveBefore = amm.baseAssetReserve;
-    }
+    const baseAssetReserveBefore = calculateSpreadReserves(amm, direction, oraclePriceData).baseAssetReserve;
     if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
         return [
             newBaseAssetReserve.sub(baseAssetReserveBefore),
@@ -261,69 +385,6 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, useSpre
     }
 }
 exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
-function calculateBudgetedK(market, 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*y*d*Q)
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const x = market.amm.baseAssetReserve;
-    const y = market.amm.quoteAssetReserve;
-    const d = market.baseAssetAmount;
-    const Q = market.amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const numer1 = y.mul(d).mul(Q).div(numericConstants_1.AMM_RESERVE_PRECISION).div(numericConstants_1.PEG_PRECISION);
-    const numer2 = C.mul(x.add(d)).div(numericConstants_1.QUOTE_PRECISION);
-    const denom1 = C.mul(x)
-        .mul(x.add(d))
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.QUOTE_PRECISION);
-    const denom2 = 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 numerator = d
-        .mul(numer1.add(numer2))
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    const denominator = denom1
-        .add(denom2)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    console.log(numerator, denominator);
-    // const p = (numerator).div(denominator);
-    // const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
-    // console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
-    return [numerator, denominator];
-}
-exports.calculateBudgetedK = calculateBudgetedK;
-function calculateBudgetedPeg(market, 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*y*d*Q)
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const x = market.amm.baseAssetReserve;
-    const y = market.amm.quoteAssetReserve;
-    const d = market.baseAssetAmount;
-    const Q = market.amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO))
-        .mul(numericConstants_1.PEG_PRECISION)
-        .div(numericConstants_1.QUOTE_PRECISION);
-    console.log(Q.toNumber(), 'change by', deltaPegMultiplier.toNumber() / numericConstants_1.MARK_PRICE_PRECISION.toNumber());
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
-    return newPeg;
-}
-exports.calculateBudgetedPeg = calculateBudgetedPeg;
 function calculateQuoteAssetAmountSwapped(quoteAssetReserves, pegMultiplier, swapDirection) {
     let quoteAssetAmount = quoteAssetReserves
         .mul(pegMultiplier)

package/lib/math/auction.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="bn.js" />
+import { Order } from '../types';
+import { BN } from '../.';
+export declare function isAuctionComplete(order: Order, slot: number): boolean;
+export declare function getAuctionPrice(order: Order, slot: number): BN;

package/lib/math/auction.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuctionPrice = exports.isAuctionComplete = void 0;
+const types_1 = require("../types");
+const _1 = require("../.");
+function isAuctionComplete(order, slot) {
+    return new _1.BN(slot).sub(order.slot).gte(new _1.BN(order.auctionDuration));
+}
+exports.isAuctionComplete = isAuctionComplete;
+function getAuctionPrice(order, slot) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    const deltaDenominator = new _1.BN(order.auctionDuration);
+    const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
+    if (deltaDenominator.eq(_1.ZERO)) {
+        return order.auctionEndPrice;
+    }
+    let priceDelta;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        priceDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let price;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        price = order.auctionStartPrice.add(priceDelta);
+    }
+    else {
+        price = order.auctionStartPrice.sub(priceDelta);
+    }
+    return price;
+}
+exports.getAuctionPrice = getAuctionPrice;

package/lib/math/bankBalance.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="bn.js" />
+import { BankAccount, BankBalanceType } from '../types';
+import { BN } from '@project-serum/anchor';
+export declare function getBalance(tokenAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
+export declare function getTokenAmount(balanceAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
+export declare function calculateInterestAccumulated(bank: BankAccount, now: BN): {
+    borrowInterest: BN;
+    depositInterest: BN;
+};

package/lib/math/bankBalance.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+function getBalance(tokenAmount, bank, balanceType) {
+    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? bank.cumulativeDepositInterest
+        : bank.cumulativeBorrowInterest;
+    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
+        balance = balance.add(numericConstants_1.ONE);
+    }
+    return balance;
+}
+exports.getBalance = getBalance;
+function getTokenAmount(balanceAmount, bank, balanceType) {
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? bank.cumulativeDepositInterest
+        : bank.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function calculateInterestAccumulated(bank, now) {
+    const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
+    const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
+    let utilization;
+    if (token_borrow_amount.eq(numericConstants_1.ZERO) && token_deposit_amount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.ZERO;
+    }
+    else if (token_deposit_amount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.BANK_UTILIZATION_PRECISION;
+    }
+    else {
+        utilization = token_borrow_amount
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(token_deposit_amount);
+    }
+    let interest_rate;
+    if (utilization.gt(bank.optimalUtilization)) {
+        const surplusUtilization = utilization.sub(bank.optimalUtilization);
+        const borrowRateSlope = bank.maxBorrowRate
+            .sub(bank.optimalBorrowRate)
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interest_rate = bank.optimalBorrowRate.add(surplusUtilization.mul(borrowRateSlope).div(numericConstants_1.BANK_UTILIZATION_PRECISION));
+    }
+    else {
+        const borrowRateSlope = bank.optimalBorrowRate
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interest_rate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
+    }
+    const timeSinceLastUpdate = now.sub(bank.lastUpdated);
+    const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
+    const modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
+    const borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.BANK_INTEREST_PRECISION)
+        .add(numericConstants_1.ONE);
+    const depositInterest = bank.cumulativeDepositInterest
+        .mul(modifiedDepositRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.BANK_INTEREST_PRECISION);
+    return { borrowInterest, depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;

package/lib/math/conversion.d.ts

@@ -1,3 +1,2 @@
 import { BN } from '../';
 export declare const convertToNumber: (bigNumber: BN, precision?: BN) => number;
-export declare const convertBaseAssetAmountToNumber: (baseAssetAmount: BN) => number;

package/lib/math/conversion.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertBaseAssetAmountToNumber = exports.convertToNumber = void 0;
+exports.convertToNumber = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PRECISION) => {
     if (!bigNumber)
@@ -9,7 +9,3 @@ const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PR
         bigNumber.mod(precision).toNumber() / precision.toNumber());
 };
 exports.convertToNumber = convertToNumber;
-const convertBaseAssetAmountToNumber = (baseAssetAmount) => {
-    return (0, exports.convertToNumber)(baseAssetAmount, numericConstants_1.MARK_PRICE_PRECISION.mul(numericConstants_1.PEG_PRECISION));
-};
-exports.convertBaseAssetAmountToNumber = convertBaseAssetAmountToNumber;