@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+exports.pyth = exports.PublicKey = exports.BN = void 0;
+var anchor_1 = require("@project-serum/anchor");
+exports.BN = anchor_1.BN;
+var web3_js_1 = require("@solana/web3.js");
+exports.PublicKey = web3_js_1.PublicKey;
+var client_1 = require("@pythnetwork/client");
+exports.pyth = client_1["default"];
+__exportStar(require("./tokenFaucet"), exports);
+__exportStar(require("./oracles/types"), exports);
+__exportStar(require("./oracles/pythClient"), exports);
+__exportStar(require("./oracles/switchboardClient"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants/perpMarkets"), exports);
+__exportStar(require("./accounts/fetch"), exports);
+__exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/bulkAccountLoader"), exports);
+__exportStar(require("./accounts/bulkUserSubscription"), exports);
+__exportStar(require("./accounts/bulkUserStatsSubscription"), exports);
+__exportStar(require("./accounts/pollingClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/pollingOracleSubscriber"), exports);
+__exportStar(require("./accounts/pollingTokenAccountSubscriber"), exports);
+__exportStar(require("./accounts/pollingUserAccountSubscriber"), exports);
+__exportStar(require("./accounts/pollingUserStatsAccountSubscriber"), exports);
+__exportStar(require("./accounts/types"), exports);
+__exportStar(require("./addresses/pda"), exports);
+__exportStar(require("./admin"), exports);
+__exportStar(require("./clearingHouseUser"), exports);
+__exportStar(require("./clearingHouseUserConfig"), exports);
+__exportStar(require("./clearingHouseUserStats"), exports);
+__exportStar(require("./clearingHouseUserStatsConfig"), exports);
+__exportStar(require("./clearingHouse"), exports);
+__exportStar(require("./factory/oracleClient"), exports);
+__exportStar(require("./factory/bigNum"), exports);
+__exportStar(require("./events/types"), exports);
+__exportStar(require("./events/eventSubscriber"), exports);
+__exportStar(require("./events/fetchLogs"), exports);
+__exportStar(require("./math/auction"), exports);
+__exportStar(require("./math/spotMarket"), exports);
+__exportStar(require("./math/conversion"), exports);
+__exportStar(require("./math/funding"), 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("./math/margin"), exports);
+__exportStar(require("./math/insurance"), exports);
+__exportStar(require("./orderParams"), exports);
+__exportStar(require("./slot/SlotSubscriber"), exports);
+__exportStar(require("./wallet"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./math/utils"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./constants/numericConstants"), exports);
+__exportStar(require("./serum/serumSubscriber"), exports);
+__exportStar(require("./tx/retryTxSender"), exports);
+__exportStar(require("./util/computeUnits"), exports);
+__exportStar(require("./util/tps"), exports);
+__exportStar(require("./math/spotBalance"), exports);
+__exportStar(require("./constants/spotMarkets"), exports);
+__exportStar(require("./clearingHouseConfig"), exports);

package/src/index.ts

@@ -7,7 +7,7 @@ export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
 export * from './types';
-export * from './constants/markets';
+export * from './constants/perpMarkets';
 export * from './accounts/fetch';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
@@ -30,7 +30,9 @@ export * from './factory/oracleClient';
 export * from './factory/bigNum';
 export * from './events/types';
 export * from './events/eventSubscriber';
+export * from './events/fetchLogs';
 export * from './math/auction';
+export * from './math/spotMarket';
 export * from './math/conversion';
 export * from './math/funding';
 export * from './math/market';
@@ -49,11 +51,12 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './serum/serumSubscriber';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
-export * from './math/bankBalance';
-export * from './constants/banks';
+export * from './math/spotBalance';
+export * from './constants/spotMarkets';
 export * from './clearingHouseConfig';
 
 export { BN, PublicKey, pyth };

package/src/math/amm.js

@@ -0,0 +1,422 @@
+"use strict";
+exports.__esModule = true;
+exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateInventoryScale = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
+var anchor_1 = require("@project-serum/anchor");
+var numericConstants_1 = require("../constants/numericConstants");
+var types_1 = require("../types");
+var assert_1 = require("../assert/assert");
+var __1 = require("..");
+var repeg_1 = require("./repeg");
+function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
+    return anchor_1.BN.max(targetPrice
+        .mul(baseAssetReserve)
+        .div(quoteAssetReserve)
+        .add(numericConstants_1.PRICE_DIV_PEG.div(new anchor_1.BN(2)))
+        .div(numericConstants_1.PRICE_DIV_PEG), numericConstants_1.ONE);
+}
+exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
+function calculateOptimalPegAndBudget(amm, oraclePriceData) {
+    var markPriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    var targetPrice = oraclePriceData.price;
+    var newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
+    var prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
+    var totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
+    var budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
+    if (budget.lt(prePegCost)) {
+        var maxPriceSpread = new anchor_1.BN(amm.maxSpread)
+            .mul(targetPrice)
+            .div(numericConstants_1.BID_ASK_SPREAD_PRECISION);
+        var newTargetPrice = void 0;
+        var newOptimalPeg = void 0;
+        var newBudget = void 0;
+        var targetPriceGap = markPriceBefore.sub(targetPrice);
+        if (targetPriceGap.abs().gt(maxPriceSpread)) {
+            var 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) {
+    var _a;
+    var pKNumer = new anchor_1.BN(1);
+    var pKDenom = new anchor_1.BN(1);
+    var _b = calculateOptimalPegAndBudget(amm, oraclePriceData), targetPrice = _b[0], _newPeg = _b[1], budget = _b[2], checkLowerBound = _b[3];
+    var prePegCost = (0, repeg_1.calculateRepegCost)(amm, _newPeg);
+    var newPeg = _newPeg;
+    if (prePegCost.gt(budget) && checkLowerBound) {
+        _a = [new anchor_1.BN(999), new anchor_1.BN(1000)], pKNumer = _a[0], pKDenom = _a[1];
+        var deficitMadeup = (0, repeg_1.calculateAdjustKCost)(amm, pKNumer, pKDenom);
+        (0, assert_1.assert)(deficitMadeup.lte(new anchor_1.BN(0)));
+        prePegCost = budget.add(deficitMadeup.abs());
+        var newAmm = Object.assign({}, amm);
+        newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
+        newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
+        var invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
+        newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
+        var directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+            ? types_1.PositionDirection.SHORT
+            : types_1.PositionDirection.LONG;
+        var _c = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose)), newQuoteAssetReserve = _c[0], _newBaseAssetReserve = _c[1];
+        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;
+    }
+    var newAmm = Object.assign({}, amm);
+    var _a = calculateNewAmm(amm, oraclePriceData), prepegCost = _a[0], pKNumer = _a[1], pKDenom = _a[2], newPeg = _a[3];
+    newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
+    newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
+    var invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
+    newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
+    newAmm.pegMultiplier = newPeg;
+    var directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.SHORT
+        : types_1.PositionDirection.LONG;
+    var _b = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose)), newQuoteAssetReserve = _b[0], _newBaseAssetReserve = _b[1];
+    newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
+    newAmm.totalFeeMinusDistributions =
+        newAmm.totalFeeMinusDistributions.sub(prepegCost);
+    return newAmm;
+}
+exports.calculateUpdatedAMM = calculateUpdatedAMM;
+function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
+    var newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+    var dirReserves = calculateSpreadReserves(newAmm, direction, oraclePriceData);
+    var result = {
+        baseAssetReserve: dirReserves.baseAssetReserve,
+        quoteAssetReserve: dirReserves.quoteAssetReserve,
+        sqrtK: newAmm.sqrtK,
+        newPeg: newAmm.pegMultiplier
+    };
+    return result;
+}
+exports.calculateUpdatedAMMSpreadReserves = calculateUpdatedAMMSpreadReserves;
+function calculateBidAskPrice(amm, oraclePriceData, withUpdate) {
+    if (withUpdate === void 0) { withUpdate = true; }
+    var newAmm;
+    if (withUpdate) {
+        newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+    }
+    else {
+        newAmm = amm;
+    }
+    var askReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.LONG, oraclePriceData);
+    var bidReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.SHORT, oraclePriceData);
+    var askPrice = calculatePrice(askReserves.baseAssetReserve, askReserves.quoteAssetReserve, newAmm.pegMultiplier);
+    var 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 baseAssetReserves
+ * @param quoteAssetReserves
+ * @param pegMultiplier
+ * @returns price : Precision MARK_PRICE_PRECISION
+ */
+function calculatePrice(baseAssetReserves, quoteAssetReserves, pegMultiplier) {
+    if (baseAssetReserves.abs().lte(numericConstants_1.ZERO)) {
+        return new anchor_1.BN(0);
+    }
+    return quoteAssetReserves
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(pegMultiplier)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(baseAssetReserves);
+}
+exports.calculatePrice = calculatePrice;
+/**
+ * Calculates what the amm reserves would be after swapping a quote or base asset amount.
+ *
+ * @param amm
+ * @param inputAssetType
+ * @param swapAmount
+ * @param swapDirection
+ * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
+ */
+function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDirection) {
+    var _a, _b;
+    (0, assert_1.assert)(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
+    var newQuoteAssetReserve;
+    var newBaseAssetReserve;
+    if (inputAssetType === 'quote') {
+        swapAmount = swapAmount
+            .mul(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+            .div(amm.pegMultiplier);
+        _a = calculateSwapOutput(amm.quoteAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK)), newQuoteAssetReserve = _a[0], newBaseAssetReserve = _a[1];
+    }
+    else {
+        _b = calculateSwapOutput(amm.baseAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK)), newBaseAssetReserve = _b[0], newQuoteAssetReserve = _b[1];
+    }
+    return [newQuoteAssetReserve, newBaseAssetReserve];
+}
+exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
+function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+    // open orders
+    var openAsks;
+    if (maxBaseAssetReserve > baseAssetReserve) {
+        openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new anchor_1.BN(-1));
+    }
+    else {
+        openAsks = numericConstants_1.ZERO;
+    }
+    var openBids;
+    if (minBaseAssetReserve < baseAssetReserve) {
+        openBids = baseAssetReserve.sub(minBaseAssetReserve);
+    }
+    else {
+        openBids = numericConstants_1.ZERO;
+    }
+    return [openBids, openAsks];
+}
+exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
+function calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+    // inventory skew
+    var _a = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve), openBids = _a[0], openAsks = _a[1];
+    var totalLiquidity = anchor_1.BN.max(openBids.abs().add(openAsks.abs()), new anchor_1.BN(1));
+    var inventoryScale = anchor_1.BN.min(netBaseAssetAmount.abs(), totalLiquidity)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(5)))
+        .div(totalLiquidity)
+        .toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
+    return inventoryScale;
+}
+exports.calculateInventoryScale = calculateInventoryScale;
+function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+    // inventory skew
+    var netBaseAssetValue = quoteAssetReserve
+        .sub(terminalQuoteAssetReserve)
+        .mul(pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    var localBaseAssetValue = netBaseAssetAmount
+        .mul(markPrice)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+    var 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) {
+    var 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, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+    var longSpread = baseSpread / 2;
+    var 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());
+    }
+    var maxTargetSpread = Math.max(maxSpread, lastOracleMarkSpreadPct.abs().toNumber());
+    var MAX_INVENTORY_SKEW = 5;
+    var inventoryScale = calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
+    var inventorySpreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + inventoryScale);
+    if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+        longSpread *= inventorySpreadScale;
+    }
+    else if (netBaseAssetAmount.lt(numericConstants_1.ZERO)) {
+        shortSpread *= inventorySpreadScale;
+    }
+    var effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions);
+    if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
+        var spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+            longSpread *= spreadScale;
+        }
+        else {
+            shortSpread *= spreadScale;
+        }
+    }
+    else {
+        longSpread *= MAX_INVENTORY_SKEW;
+        shortSpread *= MAX_INVENTORY_SKEW;
+    }
+    var 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) {
+    if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
+        return amm.baseSpread / 2;
+    }
+    var markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    var targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
+    var confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
+    var targetMarkSpreadPct = markPrice
+        .sub(targetPrice)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(markPrice);
+    var confIntervalPct = confInterval
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(markPrice);
+    var _a = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve), longSpread = _a[0], shortSpread = _a[1];
+    var spread;
+    if ((0, types_1.isVariant)(direction, 'long')) {
+        spread = longSpread;
+    }
+    else {
+        spread = shortSpread;
+    }
+    return spread;
+}
+exports.calculateSpread = calculateSpread;
+function calculateSpreadReserves(amm, direction, oraclePriceData) {
+    var spread = calculateSpread(amm, direction, oraclePriceData);
+    if (spread === 0) {
+        return {
+            baseAssetReserve: amm.baseAssetReserve,
+            quoteAssetReserve: amm.quoteAssetReserve
+        };
+    }
+    var quoteAsserReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
+    var quoteAssetReserve;
+    if ((0, types_1.isVariant)(direction, 'long')) {
+        quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
+    }
+    else {
+        quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
+    }
+    var baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
+    return {
+        baseAssetReserve: baseAssetReserve,
+        quoteAssetReserve: quoteAssetReserve
+    };
+}
+exports.calculateSpreadReserves = calculateSpreadReserves;
+/**
+ * Helper function calculating constant product curve output. Agnostic to whether input asset is quote or base
+ *
+ * @param inputAssetReserve
+ * @param swapAmount
+ * @param swapDirection
+ * @param invariant
+ * @returns newInputAssetReserve and newOutputAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
+ */
+function calculateSwapOutput(inputAssetReserve, swapAmount, swapDirection, invariant) {
+    var newInputAssetReserve;
+    if (swapDirection === types_1.SwapDirection.ADD) {
+        newInputAssetReserve = inputAssetReserve.add(swapAmount);
+    }
+    else {
+        newInputAssetReserve = inputAssetReserve.sub(swapAmount);
+    }
+    var newOutputAssetReserve = invariant.div(newInputAssetReserve);
+    return [newInputAssetReserve, newOutputAssetReserve];
+}
+exports.calculateSwapOutput = calculateSwapOutput;
+/**
+ * Translate long/shorting quote/base asset into amm operation
+ *
+ * @param inputAssetType
+ * @param positionDirection
+ */
+function getSwapDirection(inputAssetType, positionDirection) {
+    if ((0, types_1.isVariant)(positionDirection, 'long') && inputAssetType === 'base') {
+        return types_1.SwapDirection.REMOVE;
+    }
+    if ((0, types_1.isVariant)(positionDirection, 'short') && inputAssetType === 'quote') {
+        return types_1.SwapDirection.REMOVE;
+    }
+    return types_1.SwapDirection.ADD;
+}
+exports.getSwapDirection = getSwapDirection;
+/**
+ * Helper function calculating terminal price of amm
+ *
+ * @param market
+ * @returns cost : Precision MARK_PRICE_PRECISION
+ */
+function calculateTerminalPrice(market) {
+    var directionToClose = market.amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.SHORT
+        : types_1.PositionDirection.LONG;
+    var _a = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose)), newQuoteAssetReserve = _a[0], newBaseAssetReserve = _a[1];
+    var terminalPrice = newQuoteAssetReserve
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(market.amm.pegMultiplier)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(newBaseAssetReserve);
+    return terminalPrice;
+}
+exports.calculateTerminalPrice = calculateTerminalPrice;
+function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oraclePriceData) {
+    var invariant = amm.sqrtK.mul(amm.sqrtK);
+    var newBaseAssetReserveSquared = invariant
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(amm.pegMultiplier)
+        .div(limit_price)
+        .div(numericConstants_1.PEG_PRECISION);
+    var newBaseAssetReserve = (0, __1.squareRootBN)(newBaseAssetReserveSquared);
+    var baseAssetReserveBefore = calculateSpreadReserves(amm, direction, oraclePriceData).baseAssetReserve;
+    if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
+        return [
+            newBaseAssetReserve.sub(baseAssetReserveBefore),
+            types_1.PositionDirection.SHORT,
+        ];
+    }
+    else if (newBaseAssetReserve.lt(baseAssetReserveBefore)) {
+        return [
+            baseAssetReserveBefore.sub(newBaseAssetReserve),
+            types_1.PositionDirection.LONG,
+        ];
+    }
+    else {
+        console.log('tradeSize Too Small');
+        return [new anchor_1.BN(0), types_1.PositionDirection.LONG];
+    }
+}
+exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
+function calculateQuoteAssetAmountSwapped(quoteAssetReserves, pegMultiplier, swapDirection) {
+    var quoteAssetAmount = quoteAssetReserves
+        .mul(pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    if ((0, types_1.isVariant)(swapDirection, 'remove')) {
+        quoteAssetAmount = quoteAssetAmount.add(numericConstants_1.ONE);
+    }
+    return quoteAssetAmount;
+}
+exports.calculateQuoteAssetAmountSwapped = calculateQuoteAssetAmountSwapped;
+function calculateMaxBaseAssetAmountFillable(amm, orderDirection) {
+    var maxFillSize = amm.baseAssetReserve.div(new anchor_1.BN(amm.maxBaseAssetAmountRatio));
+    var maxBaseAssetAmountOnSide;
+    if ((0, types_1.isVariant)(orderDirection, 'long')) {
+        maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.baseAssetReserve.sub(amm.minBaseAssetReserve));
+    }
+    else {
+        maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.maxBaseAssetReserve.sub(amm.baseAssetReserve));
+    }
+    return (0, __1.standardizeBaseAssetAmount)(anchor_1.BN.min(maxFillSize, maxBaseAssetAmountOnSide), amm.baseAssetAmountStepSize);
+}
+exports.calculateMaxBaseAssetAmountFillable = calculateMaxBaseAssetAmountFillable;

package/src/math/amm.ts

@@ -15,7 +15,7 @@ import {
 	AMM,
 	PositionDirection,
 	SwapDirection,
-	MarketAccount,
+	PerpMarketAccount,
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
@@ -308,6 +308,51 @@ export function calculateAmmReservesAfterSwap(
 	return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 
+export function calculateMarketOpenBidAsk(
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): [BN, BN] {
+	// open orders
+	let openAsks;
+	if (maxBaseAssetReserve > baseAssetReserve) {
+		openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new BN(-1));
+	} else {
+		openAsks = ZERO;
+	}
+
+	let openBids;
+	if (minBaseAssetReserve < baseAssetReserve) {
+		openBids = baseAssetReserve.sub(minBaseAssetReserve);
+	} else {
+		openBids = ZERO;
+	}
+	return [openBids, openAsks];
+}
+
+export function calculateInventoryScale(
+	netBaseAssetAmount: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): number {
+	// inventory skew
+	const [openBids, openAsks] = calculateMarketOpenBidAsk(
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+
+	const totalLiquidity = BN.max(openBids.abs().add(openAsks.abs()), new BN(1));
+	const inventoryScale =
+		BN.min(netBaseAssetAmount.abs(), totalLiquidity)
+			.mul(BID_ASK_SPREAD_PRECISION.mul(new BN(5)))
+			.div(totalLiquidity)
+			.toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
+
+	return inventoryScale;
+}
+
 export function calculateEffectiveLeverage(
 	baseSpread: number,
 	quoteAssetReserve: BN,
@@ -353,7 +398,10 @@ export function calculateSpreadBN(
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
 	markPrice: BN,
-	totalFeeMinusDistributions: BN
+	totalFeeMinusDistributions: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
 ): [number, number] {
 	let longSpread = baseSpread / 2;
 	let shortSpread = baseSpread / 2;
@@ -370,10 +418,27 @@ export function calculateSpreadBN(
 		);
 	}
 
-	const maxTargetSpread: number = maxSpread;
+	const maxTargetSpread: number = Math.max(
+		maxSpread,
+		lastOracleMarkSpreadPct.abs().toNumber()
+	);
 
 	const MAX_INVENTORY_SKEW = 5;
 
+	const inventoryScale = calculateInventoryScale(
+		netBaseAssetAmount,
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+	const inventorySpreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + inventoryScale);
+
+	if (netBaseAssetAmount.gt(ZERO)) {
+		longSpread *= inventorySpreadScale;
+	} else if (netBaseAssetAmount.lt(ZERO)) {
+		shortSpread *= inventorySpreadScale;
+	}
+
 	const effectiveLeverage = calculateEffectiveLeverage(
 		baseSpread,
 		quoteAssetReserve,
@@ -447,7 +512,10 @@ export function calculateSpread(
 		amm.pegMultiplier,
 		amm.netBaseAssetAmount,
 		markPrice,
-		amm.totalFeeMinusDistributions
+		amm.totalFeeMinusDistributions,
+		amm.baseAssetReserve,
+		amm.minBaseAssetReserve,
+		amm.maxBaseAssetReserve
 	);
 
 	let spread: number;
@@ -548,7 +616,7 @@ export function getSwapDirection(
  * @param market
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
-export function calculateTerminalPrice(market: MarketAccount) {
+export function calculateTerminalPrice(market: PerpMarketAccount) {
 	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;