@drift-labs/sdk 0.2.0-temp.0 → 0.2.0-temp.1

package/src/idl/{mock_usdc_faucet.json → token_faucet.json}

@@ -1,23 +1,23 @@
 {
-  "version": "0.0.0",
-  "name": "mock_usdc_faucet",
+  "version": "0.1.0",
+  "name": "token_faucet",
   "instructions": [
     {
       "name": "initialize",
       "accounts": [
         {
-          "name": "mockUsdcFaucetState",
+          "name": "faucetConfig",
           "isMut": true,
           "isSigner": false
         },
         {
           "name": "admin",
-          "isMut": false,
+          "isMut": true,
           "isSigner": true
         },
         {
           "name": "mintAccount",
-          "isMut": false,
+          "isMut": true,
           "isSigner": false
         },
         {
@@ -29,20 +29,20 @@
           "name": "systemProgram",
           "isMut": false,
           "isSigner": false
-        }
-      ],
-      "args": [
+        },
         {
-          "name": "mockUsdcFaucetNonce",
-          "type": "u8"
+          "name": "tokenProgram",
+          "isMut": false,
+          "isSigner": false
         }
-      ]
+      ],
+      "args": []
     },
     {
       "name": "mintToUser",
       "accounts": [
         {
-          "name": "mockUsdcFaucetState",
+          "name": "faucetConfig",
           "isMut": false,
           "isSigner": false
         },
@@ -73,11 +73,42 @@
           "type": "u64"
         }
       ]
+    },
+    {
+      "name": "transferMintAuthority",
+      "accounts": [
+        {
+          "name": "faucetConfig",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "admin",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "mintAccount",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "mintAuthority",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "tokenProgram",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": []
     }
   ],
   "accounts": [
     {
-      "name": "MockUSDCFaucetState",
+      "name": "FaucetConfig",
       "type": {
         "kind": "struct",
         "fields": [
@@ -103,17 +134,9 @@
   ],
   "errors": [
     {
-      "code": 300,
+      "code": 6000,
       "name": "InvalidMintAccountAuthority",
       "msg": "Program not mint authority"
-    },
-    {
-      "code": 301,
-      "name": "Unauthorized",
-      "msg": "Signer must be MockUSDCFaucet admin"
     }
-  ],
-  "metadata": {
-    "address": "2z2DLVD3tBWc86pbvvy5qN31v1NXprM6zA5MDr2FMx64"
-  }
+  ]
 }

package/src/index.js

@@ -0,0 +1,69 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pyth = exports.PublicKey = exports.BN = void 0;
+const anchor_1 = require("@project-serum/anchor");
+Object.defineProperty(exports, "BN", { enumerable: true, get: function () { return anchor_1.BN; } });
+const web3_js_1 = require("@solana/web3.js");
+Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return web3_js_1.PublicKey; } });
+const client_1 = __importDefault(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/markets"), exports);
+__exportStar(require("./accounts/fetch"), exports);
+__exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/bulkAccountLoader"), exports);
+__exportStar(require("./accounts/bulkUserSubscription"), exports);
+__exportStar(require("./accounts/pollingClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/pollingOracleSubscriber"), exports);
+__exportStar(require("./accounts/pollingTokenAccountSubscriber"), 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("./clearingHouse"), 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/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);
+__exportStar(require("./config"), exports);
+__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/src/index.ts

@@ -1,7 +1,8 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import pyth from '@pythnetwork/client';
 
-export * from './mockUSDCFaucet';
+export * from './tokenFaucet';
 export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
@@ -49,4 +50,4 @@ export * from './math/bankBalance';
 export * from './constants/banks';
 export * from './clearingHouseConfig';
 
-export { BN, PublicKey };
+export { BN, PublicKey, pyth };

package/src/math/amm.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 = 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 = 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 = 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 = repeg_1.calculateAdjustKCost(amm, pKNumer, pKDenom);
+        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 = repeg_1.calculateBudgetedPeg(newAmm, prePegCost, targetPrice);
+        prePegCost = 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 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) {
+    assert_1.assert(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
+    let newQuoteAssetReserve;
+    let newBaseAssetReserve;
+    if (inputAssetType === 'quote') {
+        swapAmount = swapAmount
+            .mul(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+            .div(amm.pegMultiplier);
+        [newQuoteAssetReserve, newBaseAssetReserve] = calculateSwapOutput(amm.quoteAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK));
+    }
+    else {
+        [newBaseAssetReserve, newQuoteAssetReserve] = calculateSwapOutput(amm.baseAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK));
+    }
+    return [newQuoteAssetReserve, newBaseAssetReserve];
+}
+exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
+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 {
+        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) {
+    if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
+        return amm.baseSpread / 2;
+    }
+    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);
+    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions);
+    let spread;
+    if (types_1.isVariant(direction, 'long')) {
+        spread = longSpread;
+    }
+    else {
+        spread = shortSpread;
+    }
+    return spread;
+}
+exports.calculateSpread = calculateSpread;
+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 / 2)));
+    let quoteAssetReserve;
+    if (types_1.isVariant(direction, 'long')) {
+        quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
+    }
+    else {
+        quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
+    }
+    const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
+    return {
+        baseAssetReserve,
+        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) {
+    let newInputAssetReserve;
+    if (swapDirection === types_1.SwapDirection.ADD) {
+        newInputAssetReserve = inputAssetReserve.add(swapAmount);
+    }
+    else {
+        newInputAssetReserve = inputAssetReserve.sub(swapAmount);
+    }
+    const 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 (types_1.isVariant(positionDirection, 'long') && inputAssetType === 'base') {
+        return types_1.SwapDirection.REMOVE;
+    }
+    if (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) {
+    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.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+    const 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) {
+    const invariant = amm.sqrtK.mul(amm.sqrtK);
+    const newBaseAssetReserveSquared = invariant
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(amm.pegMultiplier)
+        .div(limit_price)
+        .div(numericConstants_1.PEG_PRECISION);
+    const newBaseAssetReserve = __1.squareRootBN(newBaseAssetReserveSquared);
+    const 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) {
+    let quoteAssetAmount = quoteAssetReserves
+        .mul(pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    if (types_1.isVariant(swapDirection, 'remove')) {
+        quoteAssetAmount = quoteAssetAmount.add(numericConstants_1.ONE);
+    }
+    return quoteAssetAmount;
+}
+exports.calculateQuoteAssetAmountSwapped = calculateQuoteAssetAmountSwapped;

package/src/math/amm.ts

@@ -68,6 +68,7 @@ export function calculateOptimalPegAndBudget(
 		let newOptimalPeg: BN;
 		let newBudget: BN;
 		const targetPriceGap = markPriceBefore.sub(targetPrice);
+
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
@@ -411,10 +412,8 @@ export function calculateSpread(
 	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
 ): number {
-	let spread = amm.baseSpread / 2;
-
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return spread;
+		return amm.baseSpread / 2;
 	}
 
 	const markPrice = calculatePrice(
@@ -435,54 +434,25 @@ export function calculateSpread(
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(markPrice);
 
-	// oracle retreat
-	if (
-		(isVariant(direction, 'long') && targetMarkSpreadPct.lt(ZERO)) ||
-		(isVariant(direction, 'short') && targetMarkSpreadPct.gt(ZERO))
-	) {
-		spread = Math.max(
-			spread,
-			targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber()
-		);
-	}
-
-	// inventory skew
-	const MAX_INVENTORY_SKEW = 5;
-	if (
-		(amm.netBaseAssetAmount.gt(ZERO) && isVariant(direction, 'long')) ||
-		(amm.netBaseAssetAmount.lt(ZERO) && isVariant(direction, 'short')) ||
-		amm.totalFeeMinusDistributions.eq(ZERO)
-	) {
-		const netCostBasis = amm.quoteAssetAmountLong.sub(
-			amm.quoteAssetAmountShort
-		);
-		const netBaseAssetValue = amm.quoteAssetReserve
-			.sub(amm.terminalQuoteAssetReserve)
-			.mul(amm.pegMultiplier)
-			.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-
-		const localBaseAssetValue = amm.netBaseAssetAmount
-			.mul(markPrice)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
-		const netPnl = netBaseAssetValue.sub(netCostBasis);
-		const localPnl = localBaseAssetValue.sub(netCostBasis);
-
-		let effectiveLeverage = MAX_INVENTORY_SKEW;
-		if (amm.totalFeeMinusDistributions.gt(ZERO)) {
-			effectiveLeverage =
-				localPnl.sub(netPnl).toNumber() /
-				(amm.totalFeeMinusDistributions.toNumber() + 1);
-		}
+	const [longSpread, shortSpread] = calculateSpreadBN(
+		amm.baseSpread,
+		targetMarkSpreadPct,
+		confIntervalPct,
+		amm.maxSpread,
+		amm.quoteAssetReserve,
+		amm.terminalQuoteAssetReserve,
+		amm.pegMultiplier,
+		amm.netBaseAssetAmount,
+		markPrice,
+		amm.totalFeeMinusDistributions
+	);
 
-		let spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
-		const maxTargetSpread = 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);
-		}
+	let spread: number;
 
-		spread *= spreadScale;
+	if (isVariant(direction, 'long')) {
+		spread = longSpread;
+	} else {
+		spread = shortSpread;
 	}
 
 	return spread;