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

package/src/index.ts

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

package/src/math/amm.ts

@@ -4,50 +4,189 @@ import {
 	MARK_PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	QUOTE_PRECISION,
-	AMM_RESERVE_PRECISION,
 	BID_ASK_SPREAD_PRECISION,
 	ONE,
+	// QUOTE_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
 } 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 calculateNewAmm(
+	amm: AMM,
+	oraclePriceData: OraclePriceData
+): [BN, BN, BN, BN] {
+	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));
+
+	if (prePegCost.gt(budget)) {
+		[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
+): [BN, BN] {
+	const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+	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';
@@ -100,15 +239,65 @@ export function calculateAmmReservesAfterSwap(
 
 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 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());
+	}
+
+	// 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();
+		}
+
+		spread *= Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
 	}
 
 	return spread;
@@ -116,12 +305,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 +321,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 +384,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 +399,7 @@ export function calculateTerminalPrice(market: Market) {
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			'base',
-			market.baseAssetAmount.abs(),
+			market.amm.netBaseAssetAmount.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
@@ -345,7 +416,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 +428,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 +450,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,

package/src/math/auction.ts

@@ -0,0 +1,39 @@
+import { isVariant, Order } from '../types';
+import { BN, ZERO } from '../.';
+
+export function isAuctionComplete(order: Order, slot: number): boolean {
+	return new BN(slot).sub(order.slot).gte(new BN(order.auctionDuration));
+}
+
+export function getAuctionPrice(order: Order, slot: number): BN {
+	const slotsElapsed = new BN(slot).sub(order.slot);
+
+	const deltaDenominator = new BN(order.auctionDuration);
+	const deltaNumerator = BN.min(slotsElapsed, deltaDenominator);
+
+	if (deltaDenominator.eq(ZERO)) {
+		return order.auctionEndPrice;
+	}
+
+	let priceDelta;
+	if (isVariant(order.direction, 'long')) {
+		priceDelta = order.auctionEndPrice
+			.sub(order.auctionStartPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	} else {
+		priceDelta = order.auctionStartPrice
+			.sub(order.auctionEndPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	}
+
+	let price;
+	if (isVariant(order.direction, 'long')) {
+		price = order.auctionStartPrice.add(priceDelta);
+	} else {
+		price = order.auctionStartPrice.sub(priceDelta);
+	}
+
+	return price;
+}