@drift-labs/sdk 2.38.1-beta.8 → 2.38.1-beta.9

package/src/math/spotPosition.ts

@@ -1,22 +1,38 @@
-import { SpotMarketAccount, SpotPosition } from '../types';
-import { ZERO } from '../constants/numericConstants';
+import { MarginCategory, SpotMarketAccount, SpotPosition } from '../types';
+import {
+	SPOT_MARKET_WEIGHT_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import {
+	calculateAssetWeight,
+	calculateLiabilityWeight,
 	getSignedTokenAmount,
+	getStrictTokenValue,
 	getTokenAmount,
 	getTokenValue,
 } from './spotBalance';
-import { OraclePriceData } from '../oracles/types';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
 
 export function isSpotPositionAvailable(position: SpotPosition): boolean {
 	return position.scaledBalance.eq(ZERO) && position.openOrders === 0;
 }
 
+export type OrderFillSimulation = {
+	tokenAmount: BN;
+	ordersValue: BN;
+	tokenValue: BN;
+	weight: BN;
+	weightedTokenValue: BN;
+	freeCollateralContribution;
+};
+
 export function getWorstCaseTokenAmounts(
 	spotPosition: SpotPosition,
 	spotMarketAccount: SpotMarketAccount,
-	oraclePriceData: OraclePriceData
-): [BN, BN] {
+	strictOraclePrice: StrictOraclePrice,
+	marginCategory: MarginCategory
+): OrderFillSimulation {
 	const tokenAmount = getSignedTokenAmount(
 		getTokenAmount(
 			spotPosition.scaledBalance,
@@ -26,22 +42,121 @@ export function getWorstCaseTokenAmounts(
 		spotPosition.balanceType
 	);
 
-	const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
-	const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+	const tokenValue = getStrictTokenValue(
+		tokenAmount,
+		spotMarketAccount.decimals,
+		strictOraclePrice
+	);
 
-	if (tokenAmountAllBidsFill.abs().gt(tokenAmountAllAsksFill.abs())) {
-		const worstCaseQuoteTokenAmount = getTokenValue(
-			spotPosition.openBids.neg(),
-			spotMarketAccount.decimals,
-			oraclePriceData
+	if (spotPosition.openBids.eq(ZERO) && spotPosition.openAsks.eq(ZERO)) {
+		const { weight, weightedTokenValue } = calculateWeightedTokenValue(
+			tokenAmount,
+			tokenValue,
+			strictOraclePrice.current,
+			spotMarketAccount,
+			marginCategory
 		);
-		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+		return {
+			tokenAmount,
+			ordersValue: ZERO,
+			tokenValue,
+			weight,
+			weightedTokenValue,
+			freeCollateralContribution: weightedTokenValue,
+		};
+	}
+
+	const bidsSimulation = simulateOrderFill(
+		tokenAmount,
+		tokenValue,
+		spotPosition.openBids,
+		strictOraclePrice,
+		spotMarketAccount,
+		marginCategory
+	);
+	const asksSimulation = simulateOrderFill(
+		tokenAmount,
+		tokenValue,
+		spotPosition.openAsks,
+		strictOraclePrice,
+		spotMarketAccount,
+		marginCategory
+	);
+
+	if (
+		asksSimulation.freeCollateralContribution.lt(
+			bidsSimulation.freeCollateralContribution
+		)
+	) {
+		return asksSimulation;
 	} else {
-		const worstCaseQuoteTokenAmount = getTokenValue(
-			spotPosition.openAsks.neg(),
-			spotMarketAccount.decimals,
-			oraclePriceData
+		return bidsSimulation;
+	}
+}
+
+export function calculateWeightedTokenValue(
+	tokenAmount: BN,
+	tokenValue: BN,
+	oraclePrice: BN,
+	spotMarket: SpotMarketAccount,
+	marginCategory: MarginCategory
+): { weight: BN; weightedTokenValue: BN } {
+	let weight: BN;
+	if (tokenValue.gte(ZERO)) {
+		weight = calculateAssetWeight(
+			tokenAmount,
+			oraclePrice,
+			spotMarket,
+			marginCategory
+		);
+	} else {
+		weight = calculateLiabilityWeight(
+			tokenAmount.abs(),
+			spotMarket,
+			marginCategory
 		);
-		return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
 	}
+
+	return {
+		weight: weight,
+		weightedTokenValue: tokenValue
+			.mul(weight)
+			.div(SPOT_MARKET_WEIGHT_PRECISION),
+	};
+}
+
+export function simulateOrderFill(
+	tokenAmount: BN,
+	tokenValue: BN,
+	openOrders: BN,
+	strictOraclePrice: StrictOraclePrice,
+	spotMarket: SpotMarketAccount,
+	marginCategory: MarginCategory
+): OrderFillSimulation {
+	const ordersValue = getTokenValue(openOrders.neg(), spotMarket.decimals, {
+		price: strictOraclePrice.max(),
+	});
+	const tokenAmountAfterFill = tokenAmount.add(openOrders);
+	const tokenValueAfterFill = tokenValue.add(ordersValue.neg());
+
+	const { weight, weightedTokenValue: weightedTokenValueAfterFill } =
+		calculateWeightedTokenValue(
+			tokenAmountAfterFill,
+			tokenValueAfterFill,
+			strictOraclePrice.current,
+			spotMarket,
+			marginCategory
+		);
+
+	const freeCollateralContribution =
+		weightedTokenValueAfterFill.add(ordersValue);
+
+	return {
+		tokenAmount: tokenAmountAfterFill,
+		ordersValue: ordersValue,
+		tokenValue: tokenValueAfterFill,
+		weight,
+		weightedTokenValue: weightedTokenValueAfterFill,
+		freeCollateralContribution,
+	};
 }

package/src/oracles/strictOraclePrice.ts

@@ -0,0 +1,19 @@
+import { BN } from '@coral-xyz/anchor';
+
+export class StrictOraclePrice {
+	current: BN;
+	twap?: BN;
+
+	constructor(current: BN, twap?: BN) {
+		this.current = current;
+		this.twap = twap;
+	}
+
+	public max(): BN {
+		return this.twap ? BN.max(this.twap, this.current) : this.current;
+	}
+
+	public min(): BN {
+		return this.twap ? BN.min(this.twap, this.current) : this.current;
+	}
+}

package/src/types.ts

@@ -655,6 +655,7 @@ export type SpotMarketAccount = {
 	maintenanceLiabilityWeight: number;
 	liquidatorFee: number;
 	imfFactor: number;
+	scaleInitialAssetWeightStart: BN;
 
 	withdrawGuardThreshold: BN;
 	depositTokenTwap: BN;