@drift-labs/sdk-browser 2.104.0-beta.21

package/src/math/margin.ts

@@ -0,0 +1,340 @@
+import { squareRootBN } from './utils';
+import {
+	SPOT_MARKET_WEIGHT_PRECISION,
+	SPOT_MARKET_IMF_PRECISION,
+	ZERO,
+	BID_ASK_SPREAD_PRECISION,
+	AMM_RESERVE_PRECISION,
+	MAX_PREDICTION_PRICE,
+	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+} from '../constants/numericConstants';
+import { BN } from '@coral-xyz/anchor';
+import { OraclePriceData } from '../oracles/types';
+import {
+	calculateMarketMarginRatio,
+	calculateScaledInitialAssetWeight,
+	DriftClient,
+	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.abs().mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+
+	const liabilityWeightNumerator = liabilityWeight.sub(
+		liabilityWeight.div(new BN(5))
+	);
+
+	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.abs().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;
+}
+
+/**
+ * This is _not_ the same as liability value as for prediction markets, the liability for the short in prediction market is (1 - oracle price) * base
+ * See {@link calculatePerpLiabilityValue} to get the liabiltiy value
+ * @param market
+ * @param perpPosition
+ * @param oraclePriceData
+ * @param includeOpenOrders
+ */
+export function calculateBaseAssetValueWithOracle(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
+	oraclePriceData: OraclePriceData,
+	includeOpenOrders = false
+): BN {
+	let price = oraclePriceData.price;
+	if (isVariant(market.status, 'settlement')) {
+		price = market.expiryPrice;
+	}
+
+	const baseAssetAmount = includeOpenOrders
+		? calculateWorstCaseBaseAssetAmount(
+				perpPosition,
+				market,
+				oraclePriceData.price
+		  )
+		: perpPosition.baseAssetAmount;
+
+	return baseAssetAmount.abs().mul(price).div(AMM_RESERVE_PRECISION);
+}
+
+export function calculateWorstCaseBaseAssetAmount(
+	perpPosition: PerpPosition,
+	perpMarket: PerpMarketAccount,
+	oraclePrice: BN
+): BN {
+	return calculateWorstCasePerpLiabilityValue(
+		perpPosition,
+		perpMarket,
+		oraclePrice
+	).worstCaseBaseAssetAmount;
+}
+
+export function calculateWorstCasePerpLiabilityValue(
+	perpPosition: PerpPosition,
+	perpMarket: PerpMarketAccount,
+	oraclePrice: BN
+): { worstCaseBaseAssetAmount: BN; worstCaseLiabilityValue: BN } {
+	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
+
+	const isPredictionMarket = isVariant(perpMarket.contractType, 'prediction');
+	const allBidsLiabilityValue = calculatePerpLiabilityValue(
+		allBids,
+		oraclePrice,
+		isPredictionMarket
+	);
+	const allAsksLiabilityValue = calculatePerpLiabilityValue(
+		allAsks,
+		oraclePrice,
+		isPredictionMarket
+	);
+
+	if (allAsksLiabilityValue.gte(allBidsLiabilityValue)) {
+		return {
+			worstCaseBaseAssetAmount: allAsks,
+			worstCaseLiabilityValue: allAsksLiabilityValue,
+		};
+	} else {
+		return {
+			worstCaseBaseAssetAmount: allBids,
+			worstCaseLiabilityValue: allBidsLiabilityValue,
+		};
+	}
+}
+
+export function calculatePerpLiabilityValue(
+	baseAssetAmount: BN,
+	price: BN,
+	isPredictionMarket: boolean
+): BN {
+	if (isPredictionMarket) {
+		if (baseAssetAmount.gt(ZERO)) {
+			return baseAssetAmount.mul(price).div(BASE_PRECISION);
+		} else {
+			return baseAssetAmount
+				.abs()
+				.mul(MAX_PREDICTION_PRICE.sub(price))
+				.div(BASE_PRECISION);
+		}
+	} else {
+		return baseAssetAmount.abs().mul(price).div(BASE_PRECISION);
+	}
+}
+
+/**
+ * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
+ * @param targetMarketIndex
+ * @param baseSize
+ * @returns
+ */
+export function calculateMarginUSDCRequiredForTrade(
+	driftClient: DriftClient,
+	targetMarketIndex: number,
+	baseSize: BN,
+	userMaxMarginRatio?: number,
+	userHighLeverageMode?: boolean,
+	entryPrice?: BN
+): BN {
+	const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
+
+	const price =
+		entryPrice ??
+		driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
+
+	const perpLiabilityValue = calculatePerpLiabilityValue(
+		baseSize,
+		price,
+		isVariant(targetMarket.contractType, 'prediction')
+	);
+
+	const marginRequired = new BN(
+		calculateMarketMarginRatio(
+			targetMarket,
+			baseSize.abs(),
+			'Initial',
+			userMaxMarginRatio,
+			userHighLeverageMode
+		)
+	)
+		.mul(perpLiabilityValue)
+		.div(MARGIN_PRECISION);
+
+	return marginRequired;
+}
+
+/**
+ * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
+ *
+ * Returns collateral required in the precision of the target collateral market.
+ */
+export function calculateCollateralDepositRequiredForTrade(
+	driftClient: DriftClient,
+	targetMarketIndex: number,
+	baseSize: BN,
+	collateralIndex: number,
+	userMaxMarginRatio?: number,
+	userHighLeverageMode?: boolean,
+	estEntryPrice?: BN
+): BN {
+	const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(
+		driftClient,
+		targetMarketIndex,
+		baseSize,
+		userMaxMarginRatio,
+		userHighLeverageMode,
+		estEntryPrice
+	);
+
+	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+
+	const collateralOracleData =
+		driftClient.getOracleDataForSpotMarket(collateralIndex);
+
+	const scaledAssetWeight = calculateScaledInitialAssetWeight(
+		collateralMarket,
+		collateralOracleData.price
+	);
+
+	// Base amount required to deposit = (marginRequiredUsdc / priceOfAsset) / assetWeight .. (E.g. $100 required / $10000 price / 0.5 weight)
+	const baseAmountRequired = driftClient
+		.convertToSpotPrecision(collateralIndex, marginRequiredUsdc)
+		.mul(PRICE_PRECISION) // adjust for division by oracle price
+		.mul(SPOT_MARKET_WEIGHT_PRECISION) // adjust for division by scaled asset weight
+		.div(collateralOracleData.price)
+		.div(scaledAssetWeight)
+		.div(QUOTE_PRECISION); // adjust for marginRequiredUsdc value's QUOTE_PRECISION
+
+	// TODO : Round by step size?
+
+	return baseAmountRequired;
+}
+
+export function calculateCollateralValueOfDeposit(
+	driftClient: DriftClient,
+	collateralIndex: number,
+	baseSize: BN
+): BN {
+	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+
+	const collateralOracleData =
+		driftClient.getOracleDataForSpotMarket(collateralIndex);
+
+	const scaledAssetWeight = calculateScaledInitialAssetWeight(
+		collateralMarket,
+		collateralOracleData.price
+	);
+
+	// CollateralBaseValue = oracle price * collateral base amount (and shift to QUOTE_PRECISION)
+	const collateralBaseValue = collateralOracleData.price
+		.mul(baseSize)
+		.mul(QUOTE_PRECISION)
+		.div(PRICE_PRECISION)
+		.div(new BN(10).pow(new BN(collateralMarket.decimals)));
+
+	const depositCollateralValue = collateralBaseValue
+		.mul(scaledAssetWeight)
+		.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+	return depositCollateralValue;
+}
+
+export function calculateLiquidationPrice(
+	freeCollateral: BN,
+	freeCollateralDelta: BN,
+	oraclePrice: BN
+): BN {
+	const liqPriceDelta = freeCollateral
+		.mul(QUOTE_PRECISION)
+		.div(freeCollateralDelta);
+
+	const liqPrice = oraclePrice.sub(liqPriceDelta);
+
+	if (liqPrice.lt(ZERO)) {
+		return new BN(-1);
+	}
+
+	return liqPrice;
+}

package/src/math/market.ts

@@ -0,0 +1,336 @@
+import { BN } from '@coral-xyz/anchor';
+import {
+	PerpMarketAccount,
+	PositionDirection,
+	MarginCategory,
+	SpotMarketAccount,
+	SpotBalanceType,
+	MarketType,
+} from '../types';
+import {
+	calculateAmmReservesAfterSwap,
+	calculatePrice,
+	calculateUpdatedAMMSpreadReserves,
+	getSwapDirection,
+	calculateUpdatedAMM,
+	calculateMarketOpenBidAsk,
+} from './amm';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
+import { OraclePriceData } from '../oracles/types';
+import {
+	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_TO_QUOTE_PRECISION,
+	ZERO,
+	QUOTE_SPOT_MARKET_INDEX,
+} from '../constants/numericConstants';
+import { getTokenAmount } from './spotBalance';
+import { DLOB } from '../dlob/DLOB';
+import { assert } from '../assert/assert';
+
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision PRICE_PRECISION
+ */
+export function calculateReservePrice(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+	return calculatePrice(
+		newAmm.baseAssetReserve,
+		newAmm.quoteAssetReserve,
+		newAmm.pegMultiplier
+	);
+}
+
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision PRICE_PRECISION
+ */
+export function calculateBidPrice(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const { baseAssetReserve, quoteAssetReserve, newPeg } =
+		calculateUpdatedAMMSpreadReserves(
+			market.amm,
+			PositionDirection.SHORT,
+			oraclePriceData
+		);
+
+	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return askPrice : Precision PRICE_PRECISION
+ */
+export function calculateAskPrice(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const { baseAssetReserve, quoteAssetReserve, newPeg } =
+		calculateUpdatedAMMSpreadReserves(
+			market.amm,
+			PositionDirection.LONG,
+			oraclePriceData
+		);
+
+	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+
+export function calculateNewMarketAfterTrade(
+	baseAssetAmount: BN,
+	direction: PositionDirection,
+	market: PerpMarketAccount
+): PerpMarketAccount {
+	const [newQuoteAssetReserve, newBaseAssetReserve] =
+		calculateAmmReservesAfterSwap(
+			market.amm,
+			'base',
+			baseAssetAmount.abs(),
+			getSwapDirection('base', direction)
+		);
+
+	const newAmm = Object.assign({}, market.amm);
+	const newMarket = Object.assign({}, market);
+	newMarket.amm = newAmm;
+	newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+	newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+
+	return newMarket;
+}
+
+export function calculateOracleReserveSpread(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const reservePrice = calculateReservePrice(market, oraclePriceData);
+	return calculateOracleSpread(reservePrice, oraclePriceData);
+}
+
+export function calculateOracleSpread(
+	price: BN,
+	oraclePriceData: OraclePriceData
+): BN {
+	return price.sub(oraclePriceData.price);
+}
+
+export function calculateMarketMarginRatio(
+	market: PerpMarketAccount,
+	size: BN,
+	marginCategory: MarginCategory,
+	customMarginRatio = 0,
+	userHighLeverageMode = false
+): number {
+	let marginRationInitial;
+	let marginRatioMaintenance;
+
+	if (
+		userHighLeverageMode &&
+		market.highLeverageMarginRatioInitial > 0 &&
+		market.highLeverageMarginRatioMaintenance
+	) {
+		marginRationInitial = market.highLeverageMarginRatioInitial;
+		marginRatioMaintenance = market.highLeverageMarginRatioMaintenance;
+	} else {
+		marginRationInitial = market.marginRatioInitial;
+		marginRatioMaintenance = market.marginRatioMaintenance;
+	}
+
+	let marginRatio;
+	switch (marginCategory) {
+		case 'Initial': {
+			// use lowest leverage between max allowed and optional user custom max
+			marginRatio = Math.max(
+				calculateSizePremiumLiabilityWeight(
+					size,
+					new BN(market.imfFactor),
+					new BN(marginRationInitial),
+					MARGIN_PRECISION
+				).toNumber(),
+				customMarginRatio
+			);
+			break;
+		}
+		case 'Maintenance': {
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				new BN(market.imfFactor),
+				new BN(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 calculateMarketMaxAvailableInsurance(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount
+): BN {
+	assert(spotMarket.marketIndex == QUOTE_SPOT_MARKET_INDEX);
+
+	// todo: insuranceFundAllocation technically not guaranteed to be in Insurance Fund
+	const insuranceFundAllocation =
+		perpMarket.insuranceClaim.quoteMaxInsurance.sub(
+			perpMarket.insuranceClaim.quoteSettledInsurance
+		);
+	const ammFeePool = getTokenAmount(
+		perpMarket.amm.feePool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	return insuranceFundAllocation.add(ammFeePool);
+}
+
+export function calculateNetUserPnl(
+	perpMarket: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
+		.add(perpMarket.amm.baseAssetAmountWithUnsettledLp)
+		.mul(oraclePriceData.price)
+		.div(BASE_PRECISION)
+		.div(PRICE_TO_QUOTE_PRECISION);
+
+	const netUserCostBasis = perpMarket.amm.quoteAssetAmount
+		.add(perpMarket.amm.quoteAssetAmountWithUnsettledLp)
+		.add(perpMarket.amm.netUnsettledFundingPnl);
+
+	const netUserPnl = netUserPositionValue.add(netUserCostBasis);
+
+	return netUserPnl;
+}
+
+export function calculateNetUserPnlImbalance(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount,
+	oraclePriceData: OraclePriceData,
+	applyFeePoolDiscount = true
+): BN {
+	const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
+
+	const pnlPool = getTokenAmount(
+		perpMarket.pnlPool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	let feePool = getTokenAmount(
+		perpMarket.amm.feePool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	if (applyFeePoolDiscount) {
+		feePool = feePool.div(new BN(5));
+	}
+
+	const imbalance = netUserPnl.sub(pnlPool.add(feePool));
+
+	return imbalance;
+}
+
+export function calculateAvailablePerpLiquidity(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	dlob: DLOB,
+	slot: number
+): { bids: BN; asks: BN } {
+	let [bids, asks] = calculateMarketOpenBidAsk(
+		market.amm.baseAssetReserve,
+		market.amm.minBaseAssetReserve,
+		market.amm.maxBaseAssetReserve,
+		market.amm.orderStepSize
+	);
+
+	asks = asks.abs();
+
+	for (const bid of dlob.getRestingLimitBids(
+		market.marketIndex,
+		slot,
+		MarketType.PERP,
+		oraclePriceData
+	)) {
+		bids = bids.add(
+			bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled)
+		);
+	}
+
+	for (const ask of dlob.getRestingLimitAsks(
+		market.marketIndex,
+		slot,
+		MarketType.PERP,
+		oraclePriceData
+	)) {
+		asks = asks.add(
+			ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled)
+		);
+	}
+
+	return {
+		bids: bids,
+		asks: asks,
+	};
+}