@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/src/math/orders.ts

@@ -1,21 +1,27 @@
-import { ClearingHouseUser } from '../clearingHouseUser';
-import { isOneOfVariant, isVariant, MarketAccount, Order } from '../types';
+import { User } from '../user';
+import {
+	isOneOfVariant,
+	isVariant,
+	PerpMarketAccount,
+	Order,
+	PositionDirection,
+} from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
 import { getAuctionPrice, isAuctionComplete } from './auction';
-import { calculateAskPrice, calculateBidPrice } from './market';
+import {
+	calculateMaxBaseAssetAmountFillable,
+	calculateMaxBaseAssetAmountToTrade,
+} from './amm';
 
-export function isOrderRiskIncreasing(
-	user: ClearingHouseUser,
-	order: Order
-): boolean {
+export function isOrderRiskIncreasing(user: User, order: Order): boolean {
 	if (isVariant(order.status, 'init')) {
 		return false;
 	}
 
 	const position =
-		user.getUserPosition(order.marketIndex) ||
+		user.getPerpPosition(order.marketIndex) ||
 		user.getEmptyPosition(order.marketIndex);
 
 	// if no position exists, it's risk increasing
@@ -48,7 +54,7 @@ export function isOrderRiskIncreasing(
 }
 
 export function isOrderRiskIncreasingInSameDirection(
-	user: ClearingHouseUser,
+	user: User,
 	order: Order
 ): boolean {
 	if (isVariant(order.status, 'init')) {
@@ -56,7 +62,7 @@ export function isOrderRiskIncreasingInSameDirection(
 	}
 
 	const position =
-		user.getUserPosition(order.marketIndex) ||
+		user.getPerpPosition(order.marketIndex) ||
 		user.getEmptyPosition(order.marketIndex);
 
 	// if no position exists, it's risk increasing
@@ -80,16 +86,13 @@ export function isOrderRiskIncreasingInSameDirection(
 	return false;
 }
 
-export function isOrderReduceOnly(
-	user: ClearingHouseUser,
-	order: Order
-): boolean {
+export function isOrderReduceOnly(user: User, order: Order): boolean {
 	if (isVariant(order.status, 'init')) {
 		return false;
 	}
 
 	const position =
-		user.getUserPosition(order.marketIndex) ||
+		user.getPerpPosition(order.marketIndex) ||
 		user.getEmptyPosition(order.marketIndex);
 
 	// if position is long and order is long
@@ -121,26 +124,25 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
-	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
 	let limitPrice;
-	if (!order.oraclePriceOffset.eq(ZERO)) {
-		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+	if (order.oraclePriceOffset !== 0) {
+		limitPrice = oraclePriceData.price.add(new BN(order.oraclePriceOffset));
 	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
-		if (isAuctionComplete(order, slot)) {
+		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 {
-			const bidPrice = calculateBidPrice(market, oraclePriceData);
-			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = bidPrice.sub(delta);
+			// check oracle validity?
+			const oraclePrice1Pct = oraclePriceData.price.div(new BN(100));
+			if (isVariant(order.direction, 'long')) {
+				limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
+			} else {
+				limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
+			}
 		}
 	} else {
 		limitPrice = order.price;
@@ -148,3 +150,143 @@ export function getLimitPrice(
 
 	return limitPrice;
 }
+
+export function getOptionalLimitPrice(
+	order: Order,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN | undefined {
+	if (hasLimitPrice(order, slot)) {
+		return getLimitPrice(order, oraclePriceData, slot);
+	} else {
+		return undefined;
+	}
+}
+
+export function hasLimitPrice(order: Order, slot: number): boolean {
+	return (
+		order.price.gt(ZERO) ||
+		order.oraclePriceOffset != 0 ||
+		!isAuctionComplete(order, slot)
+	);
+}
+
+export function isFillableByVAMM(
+	order: Order,
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number,
+	ts: number
+): boolean {
+	return (
+		(isAuctionComplete(order, slot) &&
+			!calculateBaseAssetAmountForAmmToFulfill(
+				order,
+				market,
+				oraclePriceData,
+				slot
+			).eq(ZERO)) ||
+		isOrderExpired(order, ts)
+	);
+}
+
+export function calculateBaseAssetAmountForAmmToFulfill(
+	order: Order,
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN {
+	if (mustBeTriggered(order) && !isTriggered(order)) {
+		return ZERO;
+	}
+
+	const limitPrice = getOptionalLimitPrice(order, oraclePriceData, slot);
+	let baseAssetAmount;
+	if (limitPrice !== undefined) {
+		baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
+			order,
+			market,
+			limitPrice,
+			oraclePriceData
+		);
+	} else {
+		baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+	}
+
+	const maxBaseAssetAmount = calculateMaxBaseAssetAmountFillable(
+		market.amm,
+		order.direction
+	);
+
+	return BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+
+export function calculateBaseAssetAmountToFillUpToLimitPrice(
+	order: Order,
+	market: PerpMarketAccount,
+	limitPrice: BN,
+	oraclePriceData: OraclePriceData
+): BN {
+	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
+		market.amm,
+		limitPrice,
+		order.direction,
+		oraclePriceData
+	);
+
+	const baseAssetAmount = standardizeBaseAssetAmount(
+		maxAmountToTrade,
+		market.amm.orderStepSize
+	);
+
+	// Check that directions are the same
+	const sameDirection = isSameDirection(direction, order.direction);
+	if (!sameDirection) {
+		return ZERO;
+	}
+
+	const baseAssetAmountUnfilled = order.baseAssetAmount.sub(
+		order.baseAssetAmountFilled
+	);
+	return baseAssetAmount.gt(baseAssetAmountUnfilled)
+		? baseAssetAmountUnfilled
+		: baseAssetAmount;
+}
+
+function isSameDirection(
+	firstDirection: PositionDirection,
+	secondDirection: PositionDirection
+): boolean {
+	return (
+		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
+		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
+	);
+}
+
+export function isOrderExpired(order: Order, ts: number): boolean {
+	if (
+		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+		!isVariant(order.status, 'open') ||
+		order.maxTs.eq(ZERO)
+	) {
+		return false;
+	}
+
+	return new BN(ts).gt(order.maxTs);
+}
+
+export function isMarketOrder(order: Order): boolean {
+	return isOneOfVariant(order.orderType, ['market', 'triggerMarket']);
+}
+
+export function isLimitOrder(order: Order): boolean {
+	return isOneOfVariant(order.orderType, ['limit', 'triggerLimit']);
+}
+
+export function mustBeTriggered(order: Order): boolean {
+	return isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']);
+}
+
+export function isTriggered(order: Order): boolean {
+	return isOneOfVariant(order.orderType, ['triggeredAbove', 'triggeredBelow']);
+}

package/src/math/position.ts

@@ -1,22 +1,23 @@
-import { BN } from '../';
+import { BN, SpotMarketAccount } from '../';
 import {
 	AMM_RESERVE_PRECISION,
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
 	AMM_TO_QUOTE_PRECISION_RATIO,
-	FUNDING_PAYMENT_PRECISION,
-	MARK_PRICE_PRECISION,
+	FUNDING_RATE_BUFFER_PRECISION,
+	PRICE_PRECISION,
 	ONE,
-	PRICE_TO_QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
 import {
 	calculateUpdatedAMM,
 	calculateUpdatedAMMSpreadReserves,
 	calculateAmmReservesAfterSwap,
 	getSwapDirection,
 } from './amm';
+import { calculateBaseAssetValueWithOracle } from './margin';
+import { calculateNetUserPnlImbalance } from './market';
 
 /**
  * calculateBaseAssetValue
@@ -27,9 +28,11 @@ import {
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
 export function calculateBaseAssetValue(
-	market: MarketAccount,
-	userPosition: UserPosition,
-	oraclePriceData: OraclePriceData
+	market: PerpMarketAccount,
+	userPosition: PerpPosition,
+	oraclePriceData: OraclePriceData,
+	useSpread = true,
+	skipUpdate = false
 ): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
@@ -38,21 +41,25 @@ export function calculateBaseAssetValue(
 	const directionToClose = findDirectionToClose(userPosition);
 	let prepegAmm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 
-	if (market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
-			calculateUpdatedAMMSpreadReserves(
-				market.amm,
-				directionToClose,
-				oraclePriceData
-			);
-		prepegAmm = {
-			baseAssetReserve,
-			quoteAssetReserve,
-			sqrtK: sqrtK,
-			pegMultiplier: newPeg,
-		};
+	if (!skipUpdate) {
+		if (market.amm.baseSpread > 0 && useSpread) {
+			const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+				calculateUpdatedAMMSpreadReserves(
+					market.amm,
+					directionToClose,
+					oraclePriceData
+				);
+			prepegAmm = {
+				baseAssetReserve,
+				quoteAssetReserve,
+				sqrtK: sqrtK,
+				pegMultiplier: newPeg,
+			};
+		} else {
+			prepegAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+		}
 	} else {
-		prepegAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+		prepegAmm = market.amm;
 	}
 
 	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
@@ -82,38 +89,36 @@ export function calculateBaseAssetValue(
  * calculatePositionPNL
  * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	withFunding = false,
 	oraclePriceData: OraclePriceData
 ): BN {
-	if (marketPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
+		return perpPosition.quoteAssetAmount;
 	}
 
-	const baseAssetValue = calculateBaseAssetValue(
+	const baseAssetValue = calculateBaseAssetValueWithOracle(
 		market,
-		marketPosition,
+		perpPosition,
 		oraclePriceData
 	);
 
-	let pnl;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
-		pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-	} else {
-		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
-	}
+	const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
+		? new BN(-1)
+		: new BN(1);
+	let pnl = baseAssetValue
+		.mul(baseAssetValueSign)
+		.add(perpPosition.quoteAssetAmount);
 
 	if (withFunding) {
-		const fundingRatePnL = calculatePositionFundingPNL(
-			market,
-			marketPosition
-		).div(PRICE_TO_QUOTE_PRECISION);
+		const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition);
 
 		pnl = pnl.add(fundingRatePnL);
 	}
@@ -121,64 +126,135 @@ export function calculatePositionPNL(
 	return pnl;
 }
 
+export function calculateClaimablePnl(
+	market: PerpMarketAccount,
+	spotMarket: SpotMarketAccount,
+	perpPosition: PerpPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	const unrealizedPnl = calculatePositionPNL(
+		market,
+		perpPosition,
+		true,
+		oraclePriceData
+	);
+
+	const fundingPnL = calculatePositionFundingPNL(market, perpPosition);
+
+	let unsettledPnl = unrealizedPnl.add(fundingPnL);
+	if (unrealizedPnl.gt(ZERO)) {
+		const excessPnlPool = BN.max(
+			ZERO,
+			calculateNetUserPnlImbalance(market, spotMarket, oraclePriceData).mul(
+				new BN(-1)
+			)
+		);
+
+		const maxPositivePnl = BN.max(
+			perpPosition.quoteAssetAmount
+				.sub(perpPosition.quoteEntryAmount)
+				.add(excessPnlPool),
+			ZERO
+		);
+
+		unsettledPnl = BN.min(maxPositivePnl, unrealizedPnl);
+	}
+	return unsettledPnl;
+}
+
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(
-	market: MarketAccount,
-	marketPosition: UserPosition
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition
 ): BN {
-	if (marketPosition.baseAssetAmount.eq(ZERO)) {
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	let ammCumulativeFundingRate: BN;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
 		ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
 	} else {
 		ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
 	}
 
 	const perPositionFundingRate = ammCumulativeFundingRate
-		.sub(marketPosition.lastCumulativeFundingRate)
-		.mul(marketPosition.baseAssetAmount)
+		.sub(perpPosition.lastCumulativeFundingRate)
+		.mul(perpPosition.baseAssetAmount)
 		.div(AMM_RESERVE_PRECISION)
-		.div(FUNDING_PAYMENT_PRECISION)
+		.div(FUNDING_RATE_BUFFER_PRECISION)
 		.mul(new BN(-1));
 
 	return perPositionFundingRate;
 }
 
-export function positionIsAvailable(position: UserPosition): boolean {
+export function positionIsAvailable(position: PerpPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
-		position.openOrders.eq(ZERO) &&
-		position.unsettledPnl.eq(ZERO)
+		position.openOrders === 0 &&
+		position.quoteAssetAmount.eq(ZERO) &&
+		position.lpShares.eq(ZERO)
 	);
 }
 
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^6)
  */
-export function calculateEntryPrice(userPosition: UserPosition): BN {
+export function calculateBreakEvenPrice(userPosition: PerpPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	return userPosition.quoteBreakEvenAmount
+		.mul(PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export function calculateEntryPrice(userPosition: PerpPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	return userPosition.quoteEntryAmount
+		.mul(PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+export function calculateCostBasis(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	return userPosition.quoteAssetAmount
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.div(userPosition.baseAssetAmount)
 		.abs();
 }
 
 export function findDirectionToClose(
-	userPosition: UserPosition
+	userPosition: PerpPosition
 ): PositionDirection {
 	return userPosition.baseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
@@ -186,15 +262,13 @@ export function findDirectionToClose(
 }
 
 export function positionCurrentDirection(
-	userPosition: UserPosition
+	userPosition: PerpPosition
 ): PositionDirection {
 	return userPosition.baseAssetAmount.gte(ZERO)
 		? PositionDirection.LONG
 		: PositionDirection.SHORT;
 }
 
-export function isEmptyPosition(userPosition: UserPosition): boolean {
-	return (
-		userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders.eq(ZERO)
-	);
+export function isEmptyPosition(userPosition: PerpPosition): boolean {
+	return userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders === 0;
 }

package/src/math/repeg.ts

@@ -1,7 +1,7 @@
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	AMM_RESERVE_PRECISION,
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -26,20 +26,20 @@ export function calculateAdjustKCost(
 	const x = amm.baseAssetReserve;
 	const y = amm.quoteAssetReserve;
 
-	const d = amm.netBaseAssetAmount;
+	const d = amm.baseAssetAmountWithAmm;
 	const Q = amm.pegMultiplier;
 
 	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
 
-	const p = numerator.mul(MARK_PRICE_PRECISION).div(denomenator);
+	const p = numerator.mul(PRICE_PRECISION).div(denomenator);
 
 	const cost = quoteScale
 		.div(x.add(d))
 		.sub(
 			quoteScale
 				.mul(p)
-				.div(MARK_PRICE_PRECISION)
-				.div(x.mul(p).div(MARK_PRICE_PRECISION).add(d))
+				.div(PRICE_PRECISION)
+				.div(x.mul(p).div(PRICE_PRECISION).add(d))
 		)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO)
 		.div(PEG_PRECISION);
@@ -98,6 +98,16 @@ export function calculateBudgetedKBN(
 		.div(QUOTE_PRECISION);
 	const denom2 = pegged_y_d_d;
 
+	// protocol is spending to increase k
+	if (C.lt(ZERO)) {
+		// thus denom1 is negative and solution is unstable
+		if (denom1.abs().gt(denom2.abs())) {
+			console.log('denom1 > denom2', denom1.toString(), denom2.toString());
+			console.log('budget cost exceeds stable K solution');
+			return [new BN(10000), new BN(1)];
+		}
+	}
+
 	const numerator = numer1.sub(numer2).div(AMM_TO_QUOTE_PRECISION_RATIO);
 	const denominator = denom1.add(denom2).div(AMM_TO_QUOTE_PRECISION_RATIO);
 
@@ -125,7 +135,7 @@ export function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN] {
 	const x = amm.baseAssetReserve;
 	const y = amm.quoteAssetReserve;
 
-	const d = amm.netBaseAssetAmount;
+	const d = amm.baseAssetAmountWithAmm;
 	const Q = amm.pegMultiplier;
 
 	const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
@@ -149,7 +159,7 @@ export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN {
 	const x = amm.baseAssetReserve;
 	const y = amm.quoteAssetReserve;
 
-	const d = amm.netBaseAssetAmount;
+	const d = amm.baseAssetAmountWithAmm;
 	const Q = amm.pegMultiplier;
 
 	const C = cost.mul(new BN(-1));
@@ -165,11 +175,11 @@ export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN {
 		return targetPeg;
 	}
 
-	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION).div(
+	const deltaPegMultiplier = C.mul(PRICE_PRECISION).div(
 		deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO)
 	);
 	const newPeg = Q.sub(
-		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+		deltaPegMultiplier.mul(PEG_PRECISION).div(PRICE_PRECISION)
 	);
 
 	return newPeg;