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

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;

package/src/math/auction.ts

@@ -2,7 +2,11 @@ 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));
+	if (order.auctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
 }
 
 export function getAuctionPrice(order: Order, slot: number): BN {

package/src/math/orders.ts

@@ -1,9 +1,10 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
+import { isOneOfVariant, isVariant, MarketAccount, Order } from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { getAuctionPrice } from './auction';
+import { getAuctionPrice, isAuctionComplete } from './auction';
+import { calculateAskPrice, calculateBidPrice } from './market';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -120,24 +121,27 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
+	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): 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);
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+		if (isAuctionComplete(order, slot)) {
+			limitPrice = getAuctionPrice(order, slot);
+		} else if (!order.price.eq(ZERO)) {
+			limitPrice = order.price;
+		} else if (isVariant(order.direction, 'long')) {
+			const askPrice = calculateAskPrice(market, oraclePriceData);
+			const delta = askPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = askPrice.add(delta);
 		} else {
-			limitPrice = floatingPrice;
+			const bidPrice = calculateBidPrice(market, oraclePriceData);
+			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = bidPrice.sub(delta);
 		}
-	} else if (
-		isVariant(order.orderType, 'market') ||
-		isVariant(order.orderType, '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/math/trade.ts

@@ -1,4 +1,4 @@
-import { MarketAccount, PositionDirection, SwapDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -78,28 +78,20 @@ export function calculateTradeSlippage(
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
-	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
-		direction,
-		amount,
-		market,
-		inputAssetType,
-		oraclePriceData,
-		useSpread
-	);
-
-	const swapDirection = isVariant(direction, 'long')
-		? SwapDirection.REMOVE
-		: SwapDirection.ADD;
-	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
-		acquiredQuote.abs(),
-		market.amm.pegMultiplier,
-		swapDirection
-	);
+	const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] =
+		calculateTradeAcquiredAmounts(
+			direction,
+			amount,
+			market,
+			inputAssetType,
+			oraclePriceData,
+			useSpread
+		);
 
-	const entryPrice = quoteAssetAmountAcquired
+	const entryPrice = acquiredQuoteAssetAmount
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.mul(MARK_PRICE_PRECISION)
-		.div(acquiredBase.abs());
+		.div(acquiredBaseReserve.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
@@ -116,8 +108,8 @@ export function calculateTradeSlippage(
 	}
 
 	const newPrice = calculatePrice(
-		amm.baseAssetReserve.sub(acquiredBase),
-		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.baseAssetReserve.sub(acquiredBaseReserve),
+		amm.quoteAssetReserve.sub(acquiredQuoteReserve),
 		amm.pegMultiplier
 	);
 
@@ -159,9 +151,9 @@ export function calculateTradeAcquiredAmounts(
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
-): [BN, BN] {
+): [BN, BN, BN] {
 	if (amount.eq(ZERO)) {
-		return [ZERO, ZERO];
+		return [ZERO, ZERO, ZERO];
 	}
 
 	const swapDirection = getSwapDirection(inputAssetType, direction);
@@ -185,7 +177,13 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	return [acquiredBase, acquiredQuote];
+	const acquiredQuoteAssetamount = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		amm.pegMultiplier,
+		swapDirection
+	);
+
+	return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
 }
 
 /**

package/src/orderParams.ts

@@ -1,154 +1,33 @@
-import {
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-	PositionDirection,
-} from './types';
+import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
 import { BN } from '@project-serum/anchor';
-import { ZERO } from './constants/numericConstants';
 
 export function getLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0,
-	postOnly = false,
-	oraclePriceOffset = ZERO,
-	immediateOrCancel = false
-): OrderParams {
-	return {
-		orderType: OrderType.LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly,
-		immediateOrCancel,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.LIMIT });
 }
 
 export function getTriggerMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
-		orderType: OrderType.TRIGGER_MARKET,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price: ZERO,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_MARKET });
 }
 
 export function getTriggerLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
-		orderType: OrderType.TRIGGER_LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+		price: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_LIMIT });
 }
 
 export function getMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	quoteAssetAmount: BN,
-	baseAssetAmount: BN,
-	reduceOnly: boolean,
-	price = ZERO,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	if (baseAssetAmount.eq(ZERO) && quoteAssetAmount.eq(ZERO)) {
-		throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-	}
-
-	return {
-		orderType: OrderType.MARKET,
-		userOrderId: 0,
-		marketIndex,
-		direction,
-		quoteAssetAmount,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'>
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.MARKET });
 }