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

package/src/math/margin.ts

@@ -0,0 +1,133 @@
+import { squareRootBN } from './utils';
+import {
+	SPOT_MARKET_WEIGHT_PRECISION,
+	SPOT_MARKET_IMF_PRECISION,
+	ZERO,
+	BID_ASK_SPREAD_PRECISION,
+	AMM_RESERVE_PRECISION,
+} from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { PerpMarketAccount, PerpPosition } from '..';
+import { isVariant } from '../types';
+import { assert } from '../assert/assert';
+
+export function calculateSizePremiumLiabilityWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	liabilityWeight: BN,
+	precision: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return liabilityWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+
+	const denom0 = BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor));
+	assert(denom0.gt(ZERO));
+	const liabilityWeightNumerator = liabilityWeight.sub(
+		liabilityWeight.div(
+			BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor))
+		)
+	);
+
+	const denom = new BN(100_000).mul(SPOT_MARKET_IMF_PRECISION).div(precision);
+	assert(denom.gt(ZERO));
+
+	const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(
+		sizeSqrt // 1e5
+			.mul(imfFactor)
+			.div(denom) // 1e5
+	);
+
+	const maxLiabilityWeight = BN.max(
+		liabilityWeight,
+		sizePremiumLiabilityWeight
+	);
+	return maxLiabilityWeight;
+}
+
+export function calculateSizeDiscountAssetWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	assetWeight: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return assetWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+	const imfNumerator = SPOT_MARKET_IMF_PRECISION.add(
+		SPOT_MARKET_IMF_PRECISION.div(new BN(10))
+	);
+
+	const sizeDiscountAssetWeight = imfNumerator
+		.mul(SPOT_MARKET_WEIGHT_PRECISION)
+		.div(
+			SPOT_MARKET_IMF_PRECISION.add(
+				sizeSqrt // 1e5
+					.mul(imfFactor)
+					.div(new BN(100_000)) // 1e5
+			)
+		);
+
+	const minAssetWeight = BN.min(assetWeight, sizeDiscountAssetWeight);
+
+	return minAssetWeight;
+}
+
+export function calculateOraclePriceForPerpMargin(
+	perpPosition: PerpPosition,
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const oraclePriceOffset = BN.min(
+		new BN(market.amm.maxSpread)
+			.mul(oraclePriceData.price)
+			.div(BID_ASK_SPREAD_PRECISION),
+		oraclePriceData.confidence.add(
+			new BN(market.amm.baseSpread)
+				.mul(oraclePriceData.price)
+				.div(BID_ASK_SPREAD_PRECISION)
+		)
+	);
+
+	let marginPrice: BN;
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
+		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+	} else {
+		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+	}
+
+	return marginPrice;
+}
+
+export function calculateBaseAssetValueWithOracle(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	let price = oraclePriceData.price;
+	if (isVariant(market.status, 'settlement')) {
+		price = market.expiryPrice;
+	}
+
+	return perpPosition.baseAssetAmount
+		.abs()
+		.mul(price)
+		.div(AMM_RESERVE_PRECISION);
+}
+
+export function calculateWorstCaseBaseAssetAmount(
+	perpPosition: PerpPosition
+): BN {
+	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
+
+	if (allBids.abs().gt(allAsks.abs())) {
+		return allBids;
+	} else {
+		return allAsks;
+	}
+}

package/src/math/market.ts

@@ -1,5 +1,11 @@
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import {
+	PerpMarketAccount,
+	PositionDirection,
+	MarginCategory,
+	SpotMarketAccount,
+	SpotBalanceType,
+} from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -7,16 +13,27 @@ import {
 	getSwapDirection,
 	calculateUpdatedAMM,
 } from './amm';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 import { OraclePriceData } from '../oracles/types';
+import {
+	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_TO_QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { getTokenAmount } from './spotBalance';
 
 /**
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-export function calculateMarkPrice(
-	market: MarketAccount,
+export function calculateReservePrice(
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
@@ -31,10 +48,10 @@ export function calculateMarkPrice(
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
 export function calculateBidPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -51,10 +68,10 @@ export function calculateBidPrice(
  * Calculates market ask price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
 export function calculateAskPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -70,8 +87,8 @@ export function calculateAskPrice(
 export function calculateNewMarketAfterTrade(
 	baseAssetAmount: BN,
 	direction: PositionDirection,
-	market: MarketAccount
-): MarketAccount {
+	market: PerpMarketAccount
+): PerpMarketAccount {
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
@@ -89,12 +106,12 @@ export function calculateNewMarketAfterTrade(
 	return newMarket;
 }
 
-export function calculateMarkOracleSpread(
-	market: MarketAccount,
+export function calculateOracleReserveSpread(
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const markPrice = calculateMarkPrice(market, oraclePriceData);
-	return calculateOracleSpread(markPrice, oraclePriceData);
+	const reservePrice = calculateReservePrice(market, oraclePriceData);
+	return calculateOracleSpread(reservePrice, oraclePriceData);
 }
 
 export function calculateOracleSpread(
@@ -103,3 +120,115 @@ export function calculateOracleSpread(
 ): BN {
 	return price.sub(oraclePriceData.price);
 }
+
+export function calculateMarketMarginRatio(
+	market: PerpMarketAccount,
+	size: BN,
+	marginCategory: MarginCategory
+): number {
+	let marginRatio;
+	switch (marginCategory) {
+		case 'Initial':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				new BN(market.imfFactor),
+				new BN(market.marginRatioInitial),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+		case 'Maintenance':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				new BN(market.imfFactor),
+				new BN(market.marginRatioMaintenance),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+	}
+
+	return marginRatio;
+}
+
+export function calculateUnrealizedAssetWeight(
+	market: PerpMarketAccount,
+	quoteSpotMarket: SpotMarketAccount,
+	unrealizedPnl: BN,
+	marginCategory: MarginCategory,
+	oraclePriceData: OraclePriceData
+): BN {
+	let assetWeight: BN;
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = new BN(market.unrealizedPnlInitialAssetWeight);
+
+			if (market.unrealizedPnlMaxImbalance.gt(ZERO)) {
+				const netUnsettledPnl = calculateNetUserPnlImbalance(
+					market,
+					quoteSpotMarket,
+					oraclePriceData
+				);
+				if (netUnsettledPnl.gt(market.unrealizedPnlMaxImbalance)) {
+					assetWeight = assetWeight
+						.mul(market.unrealizedPnlMaxImbalance)
+						.div(netUnsettledPnl);
+				}
+			}
+
+			assetWeight = calculateSizeDiscountAssetWeight(
+				unrealizedPnl,
+				new BN(market.unrealizedPnlImfFactor),
+				assetWeight
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = new BN(market.unrealizedPnlMaintenanceAssetWeight);
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateMarketAvailablePNL(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount
+): BN {
+	return getTokenAmount(
+		perpMarket.pnlPool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+}
+
+export function calculateNetUserPnl(
+	perpMarket: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
+		.mul(oraclePriceData.price)
+		.div(BASE_PRECISION)
+		.div(PRICE_TO_QUOTE_PRECISION);
+
+	const netUserCostBasis = perpMarket.amm.quoteAssetAmount;
+
+	const netUserPnl = netUserPositionValue.add(netUserCostBasis);
+
+	return netUserPnl;
+}
+
+export function calculateNetUserPnlImbalance(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
+
+	const pnlPool = getTokenAmount(
+		perpMarket.pnlPool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+
+	const imbalance = netUserPnl.sub(pnlPool);
+
+	return imbalance;
+}

package/src/math/oracles.ts

@@ -1,7 +1,29 @@
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
-import { ONE, ZERO } from '../constants/numericConstants';
-import { BN } from '../index';
+import {
+	BID_ASK_SPREAD_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_PRECISION,
+	ONE,
+	ZERO,
+} from '../constants/numericConstants';
+import { BN, PerpMarketAccount } from '../index';
+import { assert } from '../assert/assert';
+
+export function oraclePriceBands(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const maxPercentDiff =
+		market.marginRatioInitial - market.marginRatioMaintenance;
+	const offset = oraclePriceData.price
+		.mul(new BN(maxPercentDiff))
+		.div(MARGIN_PRECISION);
+
+	assert(offset.gt(ZERO));
+
+	return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
 
 export function isOracleValid(
 	amm: AMM,
@@ -9,22 +31,24 @@ export function isOracleValid(
 	oracleGuardRails: OracleGuardRails,
 	slot: number
 ): boolean {
-	const isOraclePriceNonPositive = oraclePriceData.price.lt(ZERO);
+	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
 	const isOraclePriceTooVolatile =
 		oraclePriceData.price
-			.div(BN.max(ONE, amm.lastOraclePriceTwap))
+			.div(BN.max(ONE, amm.historicalOracleData.lastOraclePriceTwap))
 			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
-		amm.lastOraclePriceTwap
+		amm.historicalOracleData.lastOraclePriceTwap
 			.div(BN.max(ONE, oraclePriceData.price))
 			.gt(oracleGuardRails.validity.tooVolatileRatio);
 
-	const isConfidenceTooLarge = oraclePriceData.price
-		.div(BN.max(ONE, oraclePriceData.confidence))
-		.lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+	const isConfidenceTooLarge = new BN(amm.baseSpread)
+		.add(BN.max(ONE, oraclePriceData.confidence))
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(oraclePriceData.price)
+		.gt(new BN(amm.maxSpread));
 
 	const oracleIsStale = oraclePriceData.slot
 		.sub(new BN(slot))
-		.gt(oracleGuardRails.validity.slotsBeforeStale);
+		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
 
 	return !(
 		!oraclePriceData.hasSufficientNumberOfDataPoints ||
@@ -34,3 +58,33 @@ export function isOracleValid(
 		isConfidenceTooLarge
 	);
 }
+
+export function isOracleTooDivergent(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	now: BN
+): boolean {
+	const sinceLastUpdate = now.sub(
+		amm.historicalOracleData.lastOraclePriceTwapTs
+	);
+	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
+	const oracleTwap5min = amm.historicalOracleData.lastOraclePriceTwap5min
+		.mul(sinceStart)
+		.add(oraclePriceData.price)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+	const oracleSpreadPct = oracleSpread.mul(PRICE_PRECISION).div(oracleTwap5min);
+
+	const tooDivergent = oracleSpreadPct
+		.abs()
+		.gte(
+			BID_ASK_SPREAD_PRECISION.mul(
+				oracleGuardRails.priceDivergence.markOracleDivergenceNumerator
+			).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator)
+		);
+
+	return tooDivergent;
+}

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,138 @@ 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 (
+		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+		order.triggered === false
+	) {
+		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']);
+}