@drift-labs/sdk 0.2.0-master.0 → 0.2.0-master.3

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,70 @@ 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 +98,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 +196,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,6 +304,108 @@ 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,
@@ -255,18 +424,26 @@ 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);
 
+	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());
+		spread = Math.max(
+			spread,
+			targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber()
+		);
 	}
 
 	// inventory skew
@@ -294,10 +471,18 @@ export function calculateSpread(
 		if (amm.totalFeeMinusDistributions.gt(ZERO)) {
 			effectiveLeverage =
 				localPnl.sub(netPnl).toNumber() /
-				amm.totalFeeMinusDistributions.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 *= Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+		spread *= spreadScale;
 	}
 
 	return spread;

package/src/math/orders.ts

@@ -1,5 +1,5 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
+import { isOneOfVariant, isVariant, Order } from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
@@ -125,18 +125,8 @@ export function getLimitPrice(
 ): BN {
 	let limitPrice;
 	if (!order.oraclePriceOffset.eq(ZERO)) {
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
-		} else {
-			limitPrice = floatingPrice;
-		}
-	} else if (
-		isVariant(order.orderType, 'market') ||
-		isVariant(order.orderType, 'triggerMarket')
-	) {
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
 		limitPrice = getAuctionPrice(order, slot);
 	} else {
 		limitPrice = order.price;

package/src/math/repeg.ts

@@ -5,6 +5,7 @@ import {
 	AMM_RESERVE_PRECISION,
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	PRICE_DIV_PEG,
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
@@ -142,7 +143,7 @@ export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN {
 	const targetPeg = targetPrice
 		.mul(amm.baseAssetReserve)
 		.div(amm.quoteAssetReserve)
-		.div(MARK_PRICE_PRECISION.div(PEG_PRECISION));
+		.div(PRICE_DIV_PEG);
 
 	const k = amm.sqrtK.mul(amm.sqrtK);
 	const x = amm.baseAssetReserve;

package/src/orders.ts

@@ -3,27 +3,13 @@ import {
 	MarketAccount,
 	Order,
 	PositionDirection,
-	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import {
-	BN,
-	calculateAmmReservesAfterSwap,
-	calculateBaseAssetValue,
-	calculateSpreadReserves,
-	ClearingHouseUser,
-	isOrderRiskIncreasingInSameDirection,
-	standardizeBaseAssetAmount,
-	TEN_THOUSAND,
-} from '.';
-import {
-	calculateMarkPrice,
-	calculateNewMarketAfterTrade,
-} from './math/market';
+import { BN, standardizeBaseAssetAmount } from '.';
+import { calculateNewMarketAfterTrade } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
-	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -182,7 +168,6 @@ export function calculateBaseAssetAmountMarketCanExecute(
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
 		return calculateAmountToTradeForTriggerLimit(market, order);
 	} else if (isVariant(order.orderType, 'market')) {
-		// should never be a market order queued
 		return ZERO;
 	} else {
 		return calculateAmountToTradeForTriggerMarket(market, order);
@@ -201,14 +186,7 @@ export function calculateAmountToTradeForLimit(
 				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
 			);
 		}
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
-		} else {
-			limitPrice = floatingPrice;
-		}
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
 	}
 
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
@@ -237,14 +215,8 @@ export function calculateAmountToTradeForTriggerLimit(
 	market: MarketAccount,
 	order: Order
 ): BN {
-	if (order.baseAssetAmountFilled.eq(ZERO)) {
-		const baseAssetAmount = calculateAmountToTradeForTriggerMarket(
-			market,
-			order
-		);
-		if (baseAssetAmount.eq(ZERO)) {
-			return ZERO;
-		}
+	if (!order.triggered) {
+		return ZERO;
 	}
 
 	return calculateAmountToTradeForLimit(market, order);
@@ -264,105 +236,9 @@ function calculateAmountToTradeForTriggerMarket(
 	market: MarketAccount,
 	order: Order
 ): BN {
-	return isTriggerConditionSatisfied(market, order)
-		? order.baseAssetAmount
-		: ZERO;
-}
-
-function isTriggerConditionSatisfied(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): boolean {
-	const markPrice = calculateMarkPrice(market, oraclePriceData);
-	if (isVariant(order.triggerCondition, 'above')) {
-		return markPrice.gt(order.triggerPrice);
-	} else {
-		return markPrice.lt(order.triggerPrice);
-	}
-}
-
-export function calculateBaseAssetAmountUserCanExecute(
-	market: MarketAccount,
-	order: Order,
-	user: ClearingHouseUser,
-	oraclePriceData?: OraclePriceData
-): BN {
-	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-	const freeCollateral = user.getFreeCollateral();
-	let quoteAssetAmount: BN;
-	if (isOrderRiskIncreasingInSameDirection(user, order)) {
-		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
-	} else {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		const positionValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
-		quoteAssetAmount = freeCollateral
-			.mul(maxLeverage)
-			.div(TEN_THOUSAND)
-			.add(positionValue.mul(TWO));
-	}
-
-	if (quoteAssetAmount.lte(ZERO)) {
+	if (!order.triggered) {
 		return ZERO;
 	}
 
-	const swapDirection = isVariant(order.direction, 'long')
-		? SwapDirection.ADD
-		: SwapDirection.REMOVE;
-
-	const useSpread = !order.postOnly;
-	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
-	if (useSpread) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			order.direction,
-			oraclePriceData
-		);
-		amm = {
-			baseAssetReserve,
-			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
-		};
-	} else {
-		amm = market.amm;
-	}
-
-	const baseAssetReservesBefore = amm.baseAssetReserve;
-	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
-		amm,
-		'quote',
-		quoteAssetAmount,
-		swapDirection
-	);
-
-	let baseAssetAmount = baseAssetReservesBefore
-		.sub(baseAssetReservesAfter)
-		.abs();
-	if (order.reduceOnly) {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		if (
-			isVariant(order.direction, 'long') &&
-			position.baseAssetAmount.gte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else if (
-			isVariant(order.direction, 'short') &&
-			position.baseAssetAmount.lte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else {
-			BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-		}
-	}
-
-	return baseAssetAmount;
+	return order.baseAssetAmount;
 }

package/src/types.ts

@@ -48,6 +48,7 @@ export class OrderAction {
 	static readonly CANCEL = { cancel: {} };
 	static readonly EXPIRE = { expire: {} };
 	static readonly FILL = { fill: {} };
+	static readonly TRIGGER = { trigger: {} };
 }
 
 export class OrderTriggerCondition {
@@ -290,6 +291,7 @@ export type AMM = {
 	lastAskPriceTwap: BN;
 	longSpread: BN;
 	shortSpread: BN;
+	maxSpread: number;
 };
 
 // # User Account Types
@@ -347,8 +349,9 @@ export type Order = {
 	reduceOnly: boolean;
 	triggerPrice: BN;
 	triggerCondition: OrderTriggerCondition;
+	triggered: boolean;
 	discountTier: OrderDiscountTier;
-	existingPositionDirection: PositionDirection,
+	existingPositionDirection: PositionDirection;
 	referrer: PublicKey;
 	postOnly: boolean;
 	immediateOrCancel: boolean;