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

package/lib/index.d.ts

@@ -6,6 +6,7 @@ export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
 export * from './types';
 export * from './constants/markets';
+export * from './accounts/fetch';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
@@ -13,24 +14,28 @@ export * from './accounts/pollingClearingHouseAccountSubscriber';
 export * from './accounts/pollingOracleSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/types';
-export * from './addresses';
+export * from './addresses/pda';
 export * from './admin';
 export * from './clearingHouseUser';
+export * from './clearingHouseUserConfig';
 export * from './clearingHouse';
-export * from './factory/clearingHouse';
-export * from './factory/clearingHouseUser';
 export * from './factory/oracleClient';
+export * from './factory/bigNum';
+export * from './events/types';
+export * from './events/eventSubscriber';
+export * from './math/auction';
 export * from './math/conversion';
 export * from './math/funding';
-export * from './math/insuranceFund';
 export * from './math/market';
 export * from './math/position';
 export * from './math/oracles';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
+export * from './math/repeg';
 export * from './orders';
 export * from './orderParams';
+export * from './slot/SlotSubscriber';
 export * from './wallet';
 export * from './types';
 export * from './math/utils';
@@ -39,4 +44,7 @@ export * from './constants/numericConstants';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
+export * from './math/bankBalance';
+export * from './constants/banks';
+export * from './clearingHouseConfig';
 export { BN, PublicKey };

package/lib/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./oracles/pythClient"), exports);
 __exportStar(require("./oracles/switchboardClient"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants/markets"), exports);
+__exportStar(require("./accounts/fetch"), exports);
 __exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), exports);
 __exportStar(require("./accounts/bulkAccountLoader"), exports);
 __exportStar(require("./accounts/bulkUserSubscription"), exports);
@@ -32,24 +33,28 @@ __exportStar(require("./accounts/pollingClearingHouseAccountSubscriber"), export
 __exportStar(require("./accounts/pollingOracleSubscriber"), exports);
 __exportStar(require("./accounts/pollingTokenAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
-__exportStar(require("./addresses"), exports);
+__exportStar(require("./addresses/pda"), exports);
 __exportStar(require("./admin"), exports);
 __exportStar(require("./clearingHouseUser"), exports);
+__exportStar(require("./clearingHouseUserConfig"), exports);
 __exportStar(require("./clearingHouse"), exports);
-__exportStar(require("./factory/clearingHouse"), exports);
-__exportStar(require("./factory/clearingHouseUser"), exports);
 __exportStar(require("./factory/oracleClient"), exports);
+__exportStar(require("./factory/bigNum"), exports);
+__exportStar(require("./events/types"), exports);
+__exportStar(require("./events/eventSubscriber"), exports);
+__exportStar(require("./math/auction"), exports);
 __exportStar(require("./math/conversion"), exports);
 __exportStar(require("./math/funding"), exports);
-__exportStar(require("./math/insuranceFund"), exports);
 __exportStar(require("./math/market"), exports);
 __exportStar(require("./math/position"), exports);
 __exportStar(require("./math/oracles"), exports);
 __exportStar(require("./math/amm"), exports);
 __exportStar(require("./math/trade"), exports);
 __exportStar(require("./math/orders"), exports);
+__exportStar(require("./math/repeg"), exports);
 __exportStar(require("./orders"), exports);
 __exportStar(require("./orderParams"), exports);
+__exportStar(require("./slot/SlotSubscriber"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./math/utils"), exports);
@@ -58,3 +63,6 @@ __exportStar(require("./constants/numericConstants"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);
+__exportStar(require("./math/bankBalance"), exports);
+__exportStar(require("./constants/banks"), exports);
+__exportStar(require("./clearingHouseConfig"), exports);

package/lib/math/amm.d.ts

@@ -1,15 +1,25 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { AMM, PositionDirection, SwapDirection, Market } from '../types';
+import { AMM, PositionDirection, SwapDirection, MarketAccount } from '../types';
+import { OraclePriceData } from '../oracles/types';
+export declare function calculateNewAmm(amm: AMM, oraclePriceData: OraclePriceData): [BN, BN, BN, BN];
+export declare function calculateUpdatedAMM(amm: AMM, oraclePriceData: OraclePriceData): AMM;
+export declare function calculateUpdatedAMMSpreadReserves(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): {
+    baseAssetReserve: BN;
+    quoteAssetReserve: BN;
+    sqrtK: BN;
+    newPeg: BN;
+};
+export declare function calculateBidAskPrice(amm: AMM, oraclePriceData: OraclePriceData): [BN, BN];
 /**
  * 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
  */
-export declare function calculatePrice(baseAssetAmount: BN, quoteAssetAmount: BN, peg_multiplier: BN): BN;
+export declare function calculatePrice(baseAssetReserves: BN, quoteAssetReserves: BN, pegMultiplier: BN): BN;
 export declare type AssetType = 'quote' | 'base';
 /**
  * Calculates what the amm reserves would be after swapping a quote or base asset amount.
@@ -21,8 +31,8 @@ export declare type AssetType = 'quote' | 'base';
  * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
  */
 export declare function calculateAmmReservesAfterSwap(amm: Pick<AMM, 'pegMultiplier' | 'quoteAssetReserve' | 'sqrtK' | 'baseAssetReserve'>, inputAssetType: AssetType, swapAmount: BN, swapDirection: SwapDirection): [BN, BN];
-export declare function calculateSpread(amm: AMM, direction: PositionDirection): number;
-export declare function calculateSpreadReserves(amm: AMM, direction: PositionDirection): {
+export declare function calculateSpread(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): number;
+export declare function calculateSpreadReserves(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): {
     baseAssetReserve: BN;
     quoteAssetReserve: BN;
 };
@@ -43,32 +53,12 @@ export declare function calculateSwapOutput(inputAssetReserve: BN, swapAmount: B
  * @param positionDirection
  */
 export declare function getSwapDirection(inputAssetType: AssetType, positionDirection: PositionDirection): SwapDirection;
-/**
- * Helper function calculating adjust k cost
- * @param market
- * @param marketIndex
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export declare function calculateAdjustKCost(market: Market, marketIndex: BN, numerator: BN, denomenator: BN): BN;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export declare function calculateRepegCost(market: Market, marketIndex: BN, newPeg: BN): BN;
 /**
  * Helper function calculating terminal price of amm
  *
  * @param market
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateTerminalPrice(market: Market): BN;
-export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN, direction: PositionDirection, useSpread: boolean): [BN, PositionDirection];
-export declare function calculateBudgetedK(market: Market, cost: BN): [BN, BN];
-export declare function calculateBudgetedPeg(market: Market, cost: BN): BN;
+export declare function calculateTerminalPrice(market: MarketAccount): BN;
+export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN, direction: PositionDirection, oraclePriceData?: OraclePriceData): [BN, PositionDirection];
 export declare function calculateQuoteAssetAmountSwapped(quoteAssetReserves: BN, pegMultiplier: BN, swapDirection: SwapDirection): BN;

package/lib/math/amm.js

@@ -1,29 +1,104 @@
 "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.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = 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 calculateNewAmm(amm, oraclePriceData) {
+    let pKNumer = new anchor_1.BN(1);
+    let pKDenom = new anchor_1.BN(1);
+    const targetPrice = oraclePriceData.price;
+    let newPeg = targetPrice
+        .mul(amm.baseAssetReserve)
+        .div(amm.quoteAssetReserve)
+        .add(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION).div(new anchor_1.BN(2)))
+        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION));
+    let 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 (prePegCost.gt(budget)) {
+        [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) {
+    const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+    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 +126,57 @@ 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 calculateSpread(amm, direction, oraclePriceData) {
+    let spread = amm.baseSpread / 2;
+    if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
+        return spread;
     }
-    else {
-        spread = amm.baseSpread;
+    const markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
+    const targetMarkSpreadPct = markPrice
+        .sub(targetPrice)
+        .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());
+    }
+    // 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();
+        }
+        spread *= Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
     }
     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 +228,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 +235,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 +247,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 +255,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 +274,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;
+};