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

package/src/math/amm.ts

@@ -4,50 +4,256 @@ import {
 	MARK_PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	QUOTE_PRECISION,
-	AMM_RESERVE_PRECISION,
 	BID_ASK_SPREAD_PRECISION,
 	ONE,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_DIV_PEG,
 } from '../constants/numericConstants';
-import { calculateBaseAssetValue } from './position';
 import {
 	AMM,
 	PositionDirection,
 	SwapDirection,
-	Market,
+	MarketAccount,
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
+import { squareRootBN } from '..';
+
+import { OraclePriceData } from '../oracles/types';
 import {
-	calculatePositionPNL,
-	calculateMarkPrice,
-	convertToNumber,
-	squareRootBN,
-} from '..';
+	calculateRepegCost,
+	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
+): [BN, BN, BN, BN] {
+	let pKNumer = new BN(1);
+	let pKDenom = new BN(1);
+
+	const [targetPrice, _newPeg, budget, checkLowerBound] =
+		calculateOptimalPegAndBudget(amm, oraclePriceData);
+	let prePegCost = calculateRepegCost(amm, _newPeg);
+	let newPeg = _newPeg;
+
+	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)));
+		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(ZERO)
+			? PositionDirection.SHORT
+			: PositionDirection.LONG;
+
+		const [newQuoteAssetReserve, _newBaseAssetReserve] =
+			calculateAmmReservesAfterSwap(
+				newAmm,
+				'base',
+				amm.netBaseAssetAmount.abs(),
+				getSwapDirection('base', directionToClose)
+			);
+
+		newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
+
+		newPeg = calculateBudgetedPeg(newAmm, prePegCost, targetPrice);
+		prePegCost = calculateRepegCost(newAmm, newPeg);
+	}
+
+	return [prePegCost, pKNumer, pKDenom, newPeg];
+}
+
+export function calculateUpdatedAMM(
+	amm: AMM,
+	oraclePriceData: OraclePriceData
+): AMM {
+	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(ZERO)
+		? PositionDirection.SHORT
+		: 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;
+}
+
+export function calculateUpdatedAMMSpreadReserves(
+	amm: AMM,
+	direction: PositionDirection,
+	oraclePriceData: OraclePriceData
+): { baseAssetReserve: BN; quoteAssetReserve: BN; sqrtK: BN; newPeg: BN } {
+	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;
+}
+
+export function calculateBidAskPrice(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	withUpdate = true
+): [BN, BN] {
+	let newAmm: AMM;
+	if (withUpdate) {
+		newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+	} else {
+		newAmm = amm;
+	}
+
+	const askReserves = calculateSpreadReserves(
+		newAmm,
+		PositionDirection.LONG,
+		oraclePriceData
+	);
+	const bidReserves = calculateSpreadReserves(
+		newAmm,
+		PositionDirection.SHORT,
+		oraclePriceData
+	);
+
+	const askPrice = calculatePrice(
+		askReserves.baseAssetReserve,
+		askReserves.quoteAssetReserve,
+		newAmm.pegMultiplier
+	);
+
+	const bidPrice = calculatePrice(
+		bidReserves.baseAssetReserve,
+		bidReserves.quoteAssetReserve,
+		newAmm.pegMultiplier
+	);
+
+	return [bidPrice, askPrice];
+}
 
 /**
  * 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 function calculatePrice(
-	baseAssetAmount: BN,
-	quoteAssetAmount: BN,
-	peg_multiplier: BN
+	baseAssetReserves: BN,
+	quoteAssetReserves: BN,
+	pegMultiplier: BN
 ): BN {
-	if (baseAssetAmount.abs().lte(ZERO)) {
+	if (baseAssetReserves.abs().lte(ZERO)) {
 		return new BN(0);
 	}
 
-	return quoteAssetAmount
+	return quoteAssetReserves
 		.mul(MARK_PRICE_PRECISION)
-		.mul(peg_multiplier)
+		.mul(pegMultiplier)
 		.div(PEG_PRECISION)
-		.div(baseAssetAmount);
+		.div(baseAssetReserves);
 }
 
 export type AssetType = 'quote' | 'base';
@@ -98,17 +304,185 @@ 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
+	direction: PositionDirection,
+	oraclePriceData: OraclePriceData
 ): number {
-	let spread;
+	let spread = amm.baseSpread / 2;
 
-	// future logic
-	if (isVariant(direction, 'long')) {
-		spread = amm.baseSpread;
-	} else {
-		spread = amm.baseSpread;
+	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
+		return spread;
+	}
+
+	const markPrice = calculatePrice(
+		amm.baseAssetReserve,
+		amm.quoteAssetReserve,
+		amm.pegMultiplier
+	);
+
+	const targetPrice = oraclePriceData?.price || markPrice;
+	const confInterval = oraclePriceData.confidence || ZERO;
+
+	const targetMarkSpreadPct = markPrice
+		.sub(targetPrice)
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(markPrice);
+
+	const confIntervalPct = confInterval
+		.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);
+		}
+
+		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);
+		}
+
+		spread *= spreadScale;
 	}
 
 	return spread;
@@ -116,12 +490,13 @@ export function calculateSpread(
 
 export function calculateSpreadReserves(
 	amm: AMM,
-	direction: PositionDirection
+	direction: PositionDirection,
+	oraclePriceData: OraclePriceData
 ): {
 	baseAssetReserve: BN;
 	quoteAssetReserve: BN;
 } {
-	const spread = calculateSpread(amm, direction);
+	const spread = calculateSpread(amm, direction, oraclePriceData);
 
 	if (spread === 0) {
 		return {
@@ -131,7 +506,7 @@ export function calculateSpreadReserves(
 	}
 
 	const quoteAsserReserveDelta = amm.quoteAssetReserve.div(
-		BID_ASK_SPREAD_PRECISION.div(new BN(spread / 4))
+		BID_ASK_SPREAD_PRECISION.div(new BN(spread / 2))
 	);
 
 	let quoteAssetReserve;
@@ -194,133 +569,14 @@ export function getSwapDirection(
 	return SwapDirection.ADD;
 }
 
-/**
- * Helper function calculating adjust k cost
- * @param market
- * @param marketIndex
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export function calculateAdjustKCost(
-	market: Market,
-	marketIndex: BN,
-	numerator: BN,
-	denomenator: BN
-): BN {
-	const netUserPosition = {
-		baseAssetAmount: market.baseAssetAmount,
-		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-		marketIndex: new BN(marketIndex),
-		quoteAssetAmount: new BN(0),
-		openOrders: new BN(0),
-	};
-
-	const currentValue = 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 = calculatePositionPNL(marketNewK, netUserPosition);
-
-	const p = 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 = PEG_PRECISION.sub(p).mul(y).div(PEG_PRECISION);
-	const numer20 = k
-		.mul(p)
-		.mul(p)
-		.div(PEG_PRECISION)
-		.div(PEG_PRECISION)
-		.div(x.mul(p).div(PEG_PRECISION).add(delta));
-	const numer21 = k.div(x.add(delta));
-
-	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));
-
-	// p.div(p.mul(x).add(delta)).sub()
-
-	return cost;
-}
-
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export function calculateRepegCost(
-	market: Market,
-	marketIndex: BN,
-	newPeg: BN
-): BN {
-	const netUserPosition = {
-		baseAssetAmount: market.baseAssetAmount,
-		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-		marketIndex: new BN(marketIndex),
-		quoteAssetAmount: new BN(0),
-		openOrders: new BN(0),
-	};
-
-	const currentValue = calculateBaseAssetValue(market, netUserPosition);
-	netUserPosition.quoteAssetAmount = currentValue;
-	const prevMarketPrice = 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',
-		convertToNumber(prevMarketPrice),
-		'to',
-		convertToNumber(calculateMarkPrice(marketNewPeg))
-	);
-
-	const cost = 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(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-	console.log(convertToNumber(cost2, QUOTE_PRECISION));
-	return cost;
-}
-
 /**
  * Helper function calculating terminal price of amm
  *
  * @param market
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
-export function calculateTerminalPrice(market: Market) {
-	const directionToClose = market.baseAssetAmount.gt(ZERO)
+export function calculateTerminalPrice(market: MarketAccount) {
+	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -328,7 +584,7 @@ export function calculateTerminalPrice(market: Market) {
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			'base',
-			market.baseAssetAmount.abs(),
+			market.amm.netBaseAssetAmount.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
@@ -345,7 +601,7 @@ export function calculateMaxBaseAssetAmountToTrade(
 	amm: AMM,
 	limit_price: BN,
 	direction: PositionDirection,
-	useSpread: boolean
+	oraclePriceData?: OraclePriceData
 ): [BN, PositionDirection] {
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
 
@@ -357,15 +613,11 @@ export function calculateMaxBaseAssetAmountToTrade(
 
 	const newBaseAssetReserve = 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 [
@@ -383,89 +635,6 @@ export function calculateMaxBaseAssetAmountToTrade(
 	}
 }
 
-export function calculateBudgetedK(market: Market, cost: BN): [BN, BN] {
-	// 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 BN(-1));
-
-	const numer1 = y.mul(d).mul(Q).div(AMM_RESERVE_PRECISION).div(PEG_PRECISION);
-	const numer2 = C.mul(x.add(d)).div(QUOTE_PRECISION);
-	const denom1 = C.mul(x)
-		.mul(x.add(d))
-		.div(AMM_RESERVE_PRECISION)
-		.div(QUOTE_PRECISION);
-	const denom2 = y
-		.mul(d)
-		.mul(d)
-		.mul(Q)
-		.div(AMM_RESERVE_PRECISION)
-		.div(AMM_RESERVE_PRECISION)
-		.div(PEG_PRECISION);
-
-	const numerator = d
-		.mul(numer1.add(numer2))
-		.div(AMM_RESERVE_PRECISION)
-		.div(AMM_RESERVE_PRECISION)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO);
-	const denominator = denom1
-		.add(denom2)
-		.div(AMM_RESERVE_PRECISION)
-		.div(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];
-}
-
-export function calculateBudgetedPeg(market: Market, cost: BN): BN {
-	// 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 BN(-1));
-
-	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION)
-		.div(deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO))
-		.mul(PEG_PRECISION)
-		.div(QUOTE_PRECISION);
-	console.log(
-		Q.toNumber(),
-		'change by',
-		deltaPegMultiplier.toNumber() / MARK_PRICE_PRECISION.toNumber()
-	);
-	const newPeg = Q.sub(
-		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
-	);
-
-	return newPeg;
-}
-
 export function calculateQuoteAssetAmountSwapped(
 	quoteAssetReserves: BN,
 	pegMultiplier: BN,