@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.10

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

@@ -6,8 +6,10 @@ import {
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
 	ONE,
-	// QUOTE_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_DIV_PEG,
 } from '../constants/numericConstants';
 import {
 	AMM,
@@ -25,6 +27,71 @@ import {
 	calculateAdjustKCost,
 	calculateBudgetedPeg,
 } from './repeg';
+
+export function calculatePegFromTargetPrice(
+	targetPrice: BN,
+	baseAssetReserve: BN,
+	quoteAssetReserve: BN
+): BN {
+	return targetPrice
+		.mul(baseAssetReserve)
+		.div(quoteAssetReserve)
+		.add(PRICE_DIV_PEG.div(new BN(2)))
+		.div(PRICE_DIV_PEG);
+}
+
+export function calculateOptimalPegAndBudget(
+	amm: AMM,
+	oraclePriceData: OraclePriceData
+): [BN, BN, BN, boolean] {
+	const markPriceBefore = calculatePrice(
+		amm.baseAssetReserve,
+		amm.quoteAssetReserve,
+		amm.pegMultiplier
+	);
+	const targetPrice = oraclePriceData.price;
+	const newPeg = calculatePegFromTargetPrice(
+		targetPrice,
+		amm.baseAssetReserve,
+		amm.quoteAssetReserve
+	);
+	const prePegCost = calculateRepegCost(amm, newPeg);
+
+	const totalFeeLB = amm.totalExchangeFee.div(new BN(2));
+	const budget = BN.max(ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
+	if (budget.lt(prePegCost)) {
+		const maxPriceSpread = new BN(amm.maxSpread)
+			.mul(targetPrice)
+			.div(BID_ASK_SPREAD_PRECISION);
+
+		let newTargetPrice: BN;
+		let newOptimalPeg: BN;
+		let newBudget: BN;
+		const targetPriceGap = markPriceBefore.sub(targetPrice);
+
+		if (targetPriceGap.abs().gt(maxPriceSpread)) {
+			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
+
+			if (targetPriceGap.lt(new BN(0))) {
+				newTargetPrice = markPriceBefore.add(markAdj);
+			} else {
+				newTargetPrice = markPriceBefore.sub(markAdj);
+			}
+
+			newOptimalPeg = calculatePegFromTargetPrice(
+				newTargetPrice,
+				amm.baseAssetReserve,
+				amm.quoteAssetReserve
+			);
+
+			newBudget = calculateRepegCost(amm, newOptimalPeg);
+			return [newTargetPrice, newOptimalPeg, newBudget, false];
+		}
+	}
+
+	return [targetPrice, newPeg, budget, true];
+}
+
 export function calculateNewAmm(
 	amm: AMM,
 	oraclePriceData: OraclePriceData
@@ -32,18 +99,12 @@ export function calculateNewAmm(
 	let pKNumer = new BN(1);
 	let pKDenom = new BN(1);
 
-	const targetPrice = oraclePriceData.price;
-	let newPeg = targetPrice
-		.mul(amm.baseAssetReserve)
-		.div(amm.quoteAssetReserve)
-		.add(MARK_PRICE_PRECISION.div(PEG_PRECISION).div(new BN(2)))
-		.div(MARK_PRICE_PRECISION.div(PEG_PRECISION));
-	let prePegCost = calculateRepegCost(amm, newPeg);
-
-	const totalFeeLB = amm.totalExchangeFee.div(new BN(2));
-	const budget = BN.max(ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
+	const [targetPrice, _newPeg, budget, checkLowerBound] =
+		calculateOptimalPegAndBudget(amm, oraclePriceData);
+	let prePegCost = calculateRepegCost(amm, _newPeg);
+	let newPeg = _newPeg;
 
-	if (prePegCost.gt(budget)) {
+	if (prePegCost.gt(budget) && checkLowerBound) {
 		[pKNumer, pKDenom] = [new BN(999), new BN(1000)];
 		const deficitMadeup = calculateAdjustKCost(amm, pKNumer, pKDenom);
 		assert(deficitMadeup.lte(new BN(0)));
@@ -136,9 +197,16 @@ export function calculateUpdatedAMMSpreadReserves(
 
 export function calculateBidAskPrice(
 	amm: AMM,
-	oraclePriceData: OraclePriceData
+	oraclePriceData: OraclePriceData,
+	withUpdate = true
 ): [BN, BN] {
-	const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+	let newAmm: AMM;
+	if (withUpdate) {
+		newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+	} else {
+		newAmm = amm;
+	}
+
 	const askReserves = calculateSpreadReserves(
 		newAmm,
 		PositionDirection.LONG,
@@ -237,15 +305,115 @@ export function calculateAmmReservesAfterSwap(
 	return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 
+export function calculateEffectiveLeverage(
+	baseSpread: number,
+	quoteAssetReserve: BN,
+	terminalQuoteAssetReserve: BN,
+	pegMultiplier: BN,
+	netBaseAssetAmount: BN,
+	markPrice: BN,
+	totalFeeMinusDistributions: BN
+): number {
+	// inventory skew
+	const netBaseAssetValue = quoteAssetReserve
+		.sub(terminalQuoteAssetReserve)
+		.mul(pegMultiplier)
+		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+
+	const localBaseAssetValue = netBaseAssetAmount
+		.mul(markPrice)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+	const effectiveLeverage =
+		localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
+			(Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
+		1 / QUOTE_PRECISION.toNumber();
+
+	return effectiveLeverage;
+}
+
+export function calculateMaxSpread(marginRatioInitial: number): number {
+	const maxTargetSpread: number = new BN(marginRatioInitial)
+		.mul(BID_ASK_SPREAD_PRECISION.div(MARGIN_PRECISION))
+		.toNumber();
+
+	return maxTargetSpread;
+}
+
+export function calculateSpreadBN(
+	baseSpread: number,
+	lastOracleMarkSpreadPct: BN,
+	lastOracleConfPct: BN,
+	maxSpread: number,
+	quoteAssetReserve: BN,
+	terminalQuoteAssetReserve: BN,
+	pegMultiplier: BN,
+	netBaseAssetAmount: BN,
+	markPrice: BN,
+	totalFeeMinusDistributions: BN
+): [number, number] {
+	let longSpread = baseSpread / 2;
+	let shortSpread = baseSpread / 2;
+
+	if (lastOracleMarkSpreadPct.gt(ZERO)) {
+		shortSpread = Math.max(
+			shortSpread,
+			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+		);
+	} else if (lastOracleMarkSpreadPct.lt(ZERO)) {
+		longSpread = Math.max(
+			longSpread,
+			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+		);
+	}
+
+	const maxTargetSpread: number = maxSpread;
+
+	const MAX_INVENTORY_SKEW = 5;
+
+	const effectiveLeverage = calculateEffectiveLeverage(
+		baseSpread,
+		quoteAssetReserve,
+		terminalQuoteAssetReserve,
+		pegMultiplier,
+		netBaseAssetAmount,
+		markPrice,
+		totalFeeMinusDistributions
+	);
+
+	if (totalFeeMinusDistributions.gt(ZERO)) {
+		const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+		if (netBaseAssetAmount.gt(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];
+}
+
 export function calculateSpread(
 	amm: AMM,
 	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(
@@ -255,49 +423,36 @@ export function calculateSpread(
 	);
 
 	const targetPrice = oraclePriceData?.price || markPrice;
+	const confInterval = oraclePriceData.confidence || ZERO;
 
 	const targetMarkSpreadPct = markPrice
 		.sub(targetPrice)
 		.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());
-	}
+	const confIntervalPct = confInterval
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(markPrice);
 
-	// 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();
-		}
+	const [longSpread, shortSpread] = calculateSpreadBN(
+		amm.baseSpread,
+		targetMarkSpreadPct,
+		confIntervalPct,
+		amm.maxSpread,
+		amm.quoteAssetReserve,
+		amm.terminalQuoteAssetReserve,
+		amm.pegMultiplier,
+		amm.netBaseAssetAmount,
+		markPrice,
+		amm.totalFeeMinusDistributions
+	);
+
+	let spread: number;
 
-		spread *= Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+	if (isVariant(direction, 'long')) {
+		spread = longSpread;
+	} else {
+		spread = shortSpread;
 	}
 
 	return spread;