@drift-labs/sdk 2.37.1-beta.6 → 2.37.1-beta.7

package/VERSION

@@ -1 +1 @@
-2.37.1-beta.6
+2.37.1-beta.7

package/lib/types.d.ts

@@ -1117,3 +1117,16 @@ export type PerpMarketExtendedInfo = {
     pnlPoolValue: BN;
     contractTier: ContractTier;
 };
+export type HealthComponents = {
+    deposits: HealthComponent[];
+    borrows: HealthComponent[];
+    perpPositions: HealthComponent[];
+    perpPnl: HealthComponent[];
+};
+export type HealthComponent = {
+    marketIndex: number;
+    size: BN;
+    value: BN;
+    weight: BN;
+    weightedValue: BN;
+};

package/lib/user.d.ts

@@ -3,7 +3,7 @@ import { PublicKey } from '@solana/web3.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { DriftClient } from './driftClient';
-import { MarginCategory, Order, UserAccount, PerpPosition, SpotPosition, PerpMarketAccount } from './types';
+import { MarginCategory, Order, UserAccount, PerpPosition, SpotPosition, PerpMarketAccount, HealthComponents } from './types';
 import { UserAccountSubscriber, UserAccountEvents, DataAndSlot } from './accounts/types';
 import { PositionDirection, BN, SpotMarketAccount, MarketType } from '.';
 import { OraclePriceData } from './oracles/types';
@@ -358,6 +358,9 @@ export declare class User {
         perpTier: number;
         spotTier: number;
     };
+    getHealthComponents({ marginCategory, }: {
+        marginCategory: MarginCategory;
+    }): HealthComponents;
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore

package/lib/user.js

@@ -464,7 +464,7 @@ class User {
             }
             positionUnrealizedPnl = positionUnrealizedPnl
                 .mul(quotePrice)
-                .div(new _1.BN(numericConstants_1.PRICE_PRECISION));
+                .div(numericConstants_1.PRICE_PRECISION);
             if (withWeightMarginCategory !== undefined) {
                 if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
                     positionUnrealizedPnl = positionUnrealizedPnl
@@ -676,7 +676,7 @@ class User {
         let baseAssetValue = baseAssetAmount
             .abs()
             .mul(valuationPrice)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
+            .div(numericConstants_1.BASE_PRECISION);
         if (marginCategory) {
             let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
             if (marginCategory === 'Initial') {
@@ -1722,6 +1722,146 @@ class User {
             spotTier: safestSpotTier,
         };
     }
+    getHealthComponents({ marginCategory, }) {
+        const healthComponents = {
+            deposits: [],
+            borrows: [],
+            perpPositions: [],
+            perpPnl: [],
+        };
+        for (const perpPosition of this.getActivePerpPositions()) {
+            const perpMarket = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            const oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(perpMarket.amm.oracle).data;
+            const oraclePrice = oraclePriceData.price;
+            const worstCaseBaseAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
+            const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory));
+            const quoteSpotMarket = this.driftClient.getSpotMarketAccount(perpMarket.quoteSpotMarketIndex);
+            const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
+            const baseAssetValue = worstCaseBaseAmount
+                .abs()
+                .mul(oraclePrice)
+                .div(numericConstants_1.BASE_PRECISION);
+            let marginRequirement = baseAssetValue
+                .mul(quoteOraclePriceData.price)
+                .div(numericConstants_1.PRICE_PRECISION)
+                .mul(marginRatio)
+                .div(numericConstants_1.MARGIN_PRECISION);
+            marginRequirement = marginRequirement.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+            if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                marginRequirement = marginRequirement.add(_1.BN.max(numericConstants_1.QUOTE_PRECISION, oraclePrice
+                    .mul(perpMarket.amm.orderStepSize)
+                    .mul(numericConstants_1.QUOTE_PRECISION)
+                    .div(numericConstants_1.AMM_RESERVE_PRECISION)
+                    .div(numericConstants_1.PRICE_PRECISION)));
+            }
+            healthComponents.perpPositions.push({
+                marketIndex: perpMarket.marketIndex,
+                size: worstCaseBaseAmount,
+                value: baseAssetValue,
+                weight: marginRatio,
+                weightedValue: marginRequirement,
+            });
+            const settledPerpPosition = this.getPerpPositionWithLPSettle(perpPosition.marketIndex, perpPosition)[0];
+            const positionUnrealizedPnl = (0, _1.calculatePositionPNL)(perpMarket, settledPerpPosition, true, oraclePriceData);
+            let pnlWeight;
+            if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                pnlWeight = (0, _1.calculateUnrealizedAssetWeight)(perpMarket, quoteSpotMarket, positionUnrealizedPnl, marginCategory, oraclePriceData);
+            }
+            else {
+                pnlWeight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
+            }
+            const pnlValue = positionUnrealizedPnl
+                .mul(quoteOraclePriceData.price)
+                .div(numericConstants_1.PRICE_PRECISION);
+            const wegithedPnlValue = pnlValue
+                .mul(pnlWeight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            healthComponents.perpPnl.push({
+                marketIndex: perpMarket.marketIndex,
+                size: positionUnrealizedPnl,
+                value: wegithedPnlValue,
+                weight: pnlWeight,
+                weightedValue: wegithedPnlValue,
+            });
+        }
+        let netQuoteValue = numericConstants_1.ZERO;
+        for (const spotPosition of this.getActiveSpotPositions()) {
+            const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                const tokenAmount = (0, _1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+                netQuoteValue = netQuoteValue.add(tokenAmount);
+                continue;
+            }
+            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, oraclePriceData);
+            netQuoteValue = netQuoteValue.add(worstCaseQuoteTokenAmount);
+            const baseAssetValue = (0, _1.getTokenValue)(worstCaseTokenAmount.abs(), spotMarketAccount.decimals, oraclePriceData);
+            const isLiability = (0, types_1.isVariant)(spotPosition.balanceType, 'borrow');
+            let weight;
+            if (isLiability) {
+                weight = (0, spotBalance_1.calculateLiabilityWeight)(worstCaseTokenAmount.abs(), spotMarketAccount, marginCategory);
+            }
+            else {
+                weight = (0, spotBalance_1.calculateAssetWeight)(worstCaseTokenAmount, spotMarketAccount, marginCategory);
+            }
+            const weightedValue = baseAssetValue
+                .mul(weight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            if (isLiability) {
+                healthComponents.borrows.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: worstCaseTokenAmount,
+                    value: baseAssetValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+            else {
+                healthComponents.deposits.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: worstCaseTokenAmount,
+                    value: weightedValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+        }
+        if (!netQuoteValue.eq(numericConstants_1.ZERO)) {
+            const spotMarketAccount = this.driftClient.getQuoteSpotMarketAccount();
+            const oraclePriceData = this.getOracleDataForSpotMarket(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+            const baseAssetValue = (0, _1.getTokenValue)(netQuoteValue.abs(), spotMarketAccount.decimals, oraclePriceData);
+            const isLiability = netQuoteValue.lt(numericConstants_1.ZERO);
+            let weight;
+            if (isLiability) {
+                weight = (0, spotBalance_1.calculateLiabilityWeight)(netQuoteValue.abs(), spotMarketAccount, marginCategory);
+            }
+            else {
+                weight = (0, spotBalance_1.calculateAssetWeight)(netQuoteValue, spotMarketAccount, marginCategory);
+            }
+            const weightedValue = baseAssetValue
+                .mul(weight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            if (isLiability) {
+                healthComponents.borrows.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: netQuoteValue,
+                    value: baseAssetValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+            else {
+                healthComponents.deposits.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: netQuoteValue,
+                    value: weightedValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+        }
+        return healthComponents;
+    }
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.37.1-beta.6",
+	"version": "2.37.1-beta.7",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/types.ts

@@ -1100,3 +1100,18 @@ export type PerpMarketExtendedInfo = {
 	pnlPoolValue: BN;
 	contractTier: ContractTier;
 };
+
+export type HealthComponents = {
+	deposits: HealthComponent[];
+	borrows: HealthComponent[];
+	perpPositions: HealthComponent[];
+	perpPnl: HealthComponent[];
+};
+
+export type HealthComponent = {
+	marketIndex: number;
+	size: BN;
+	value: BN;
+	weight: BN;
+	weightedValue: BN;
+};

package/src/user.ts

@@ -11,6 +11,7 @@ import {
 	SpotPosition,
 	isOneOfVariant,
 	PerpMarketAccount,
+	HealthComponents,
 } from './types';
 import { calculateEntryPrice, positionIsAvailable } from './math/position';
 import {
@@ -749,7 +750,7 @@ export class User {
 
 				positionUnrealizedPnl = positionUnrealizedPnl
 					.mul(quotePrice)
-					.div(new BN(PRICE_PRECISION));
+					.div(PRICE_PRECISION);
 
 				if (withWeightMarginCategory !== undefined) {
 					if (positionUnrealizedPnl.gt(ZERO)) {
@@ -1231,7 +1232,7 @@ export class User {
 		let baseAssetValue = baseAssetAmount
 			.abs()
 			.mul(valuationPrice)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
+			.div(BASE_PRECISION);
 
 		if (marginCategory) {
 			let marginRatio = new BN(
@@ -3117,6 +3118,253 @@ export class User {
 		};
 	}
 
+	public getHealthComponents({
+		marginCategory,
+	}: {
+		marginCategory: MarginCategory;
+	}): HealthComponents {
+		const healthComponents: HealthComponents = {
+			deposits: [],
+			borrows: [],
+			perpPositions: [],
+			perpPnl: [],
+		};
+
+		for (const perpPosition of this.getActivePerpPositions()) {
+			const perpMarket = this.driftClient.getPerpMarketAccount(
+				perpPosition.marketIndex
+			);
+			const oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(
+				perpMarket.amm.oracle
+			).data;
+			const oraclePrice = oraclePriceData.price;
+			const worstCaseBaseAmount =
+				calculateWorstCaseBaseAssetAmount(perpPosition);
+
+			const marginRatio = new BN(
+				calculateMarketMarginRatio(
+					perpMarket,
+					worstCaseBaseAmount.abs(),
+					marginCategory
+				)
+			);
+
+			const quoteSpotMarket = this.driftClient.getSpotMarketAccount(
+				perpMarket.quoteSpotMarketIndex
+			);
+			const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(
+				quoteSpotMarket.oracle
+			).data;
+
+			const baseAssetValue = worstCaseBaseAmount
+				.abs()
+				.mul(oraclePrice)
+				.div(BASE_PRECISION);
+
+			let marginRequirement = baseAssetValue
+				.mul(quoteOraclePriceData.price)
+				.div(PRICE_PRECISION)
+				.mul(marginRatio)
+				.div(MARGIN_PRECISION);
+
+			marginRequirement = marginRequirement.add(
+				new BN(perpPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
+			);
+
+			if (perpPosition.lpShares.gt(ZERO)) {
+				marginRequirement = marginRequirement.add(
+					BN.max(
+						QUOTE_PRECISION,
+						oraclePrice
+							.mul(perpMarket.amm.orderStepSize)
+							.mul(QUOTE_PRECISION)
+							.div(AMM_RESERVE_PRECISION)
+							.div(PRICE_PRECISION)
+					)
+				);
+			}
+
+			healthComponents.perpPositions.push({
+				marketIndex: perpMarket.marketIndex,
+				size: worstCaseBaseAmount,
+				value: baseAssetValue,
+				weight: marginRatio,
+				weightedValue: marginRequirement,
+			});
+
+			const settledPerpPosition = this.getPerpPositionWithLPSettle(
+				perpPosition.marketIndex,
+				perpPosition
+			)[0];
+
+			const positionUnrealizedPnl = calculatePositionPNL(
+				perpMarket,
+				settledPerpPosition,
+				true,
+				oraclePriceData
+			);
+
+			let pnlWeight;
+			if (positionUnrealizedPnl.gt(ZERO)) {
+				pnlWeight = calculateUnrealizedAssetWeight(
+					perpMarket,
+					quoteSpotMarket,
+					positionUnrealizedPnl,
+					marginCategory,
+					oraclePriceData
+				);
+			} else {
+				pnlWeight = SPOT_MARKET_WEIGHT_PRECISION;
+			}
+
+			const pnlValue = positionUnrealizedPnl
+				.mul(quoteOraclePriceData.price)
+				.div(PRICE_PRECISION);
+
+			const wegithedPnlValue = pnlValue
+				.mul(pnlWeight)
+				.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+			healthComponents.perpPnl.push({
+				marketIndex: perpMarket.marketIndex,
+				size: positionUnrealizedPnl,
+				value: wegithedPnlValue,
+				weight: pnlWeight,
+				weightedValue: wegithedPnlValue,
+			});
+		}
+
+		let netQuoteValue = ZERO;
+		for (const spotPosition of this.getActiveSpotPositions()) {
+			const spotMarketAccount: SpotMarketAccount =
+				this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+
+			const oraclePriceData = this.getOracleDataForSpotMarket(
+				spotPosition.marketIndex
+			);
+
+			if (spotPosition.marketIndex === QUOTE_SPOT_MARKET_INDEX) {
+				const tokenAmount = getSignedTokenAmount(
+					getTokenAmount(
+						spotPosition.scaledBalance,
+						spotMarketAccount,
+						spotPosition.balanceType
+					),
+					spotPosition.balanceType
+				);
+
+				netQuoteValue = netQuoteValue.add(tokenAmount);
+				continue;
+			}
+
+			const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] =
+				getWorstCaseTokenAmounts(
+					spotPosition,
+					spotMarketAccount,
+					oraclePriceData
+				);
+
+			netQuoteValue = netQuoteValue.add(worstCaseQuoteTokenAmount);
+
+			const baseAssetValue = getTokenValue(
+				worstCaseTokenAmount.abs(),
+				spotMarketAccount.decimals,
+				oraclePriceData
+			);
+			const isLiability = isVariant(spotPosition.balanceType, 'borrow');
+
+			let weight;
+			if (isLiability) {
+				weight = calculateLiabilityWeight(
+					worstCaseTokenAmount.abs(),
+					spotMarketAccount,
+					marginCategory
+				);
+			} else {
+				weight = calculateAssetWeight(
+					worstCaseTokenAmount,
+					spotMarketAccount,
+					marginCategory
+				);
+			}
+
+			const weightedValue = baseAssetValue
+				.mul(weight)
+				.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+			if (isLiability) {
+				healthComponents.borrows.push({
+					marketIndex: spotMarketAccount.marketIndex,
+					size: worstCaseTokenAmount,
+					value: baseAssetValue,
+					weight: weight,
+					weightedValue: weightedValue,
+				});
+			} else {
+				healthComponents.deposits.push({
+					marketIndex: spotMarketAccount.marketIndex,
+					size: worstCaseTokenAmount,
+					value: weightedValue,
+					weight: weight,
+					weightedValue: weightedValue,
+				});
+			}
+		}
+
+		if (!netQuoteValue.eq(ZERO)) {
+			const spotMarketAccount = this.driftClient.getQuoteSpotMarketAccount();
+			const oraclePriceData = this.getOracleDataForSpotMarket(
+				QUOTE_SPOT_MARKET_INDEX
+			);
+
+			const baseAssetValue = getTokenValue(
+				netQuoteValue.abs(),
+				spotMarketAccount.decimals,
+				oraclePriceData
+			);
+			const isLiability = netQuoteValue.lt(ZERO);
+
+			let weight;
+			if (isLiability) {
+				weight = calculateLiabilityWeight(
+					netQuoteValue.abs(),
+					spotMarketAccount,
+					marginCategory
+				);
+			} else {
+				weight = calculateAssetWeight(
+					netQuoteValue,
+					spotMarketAccount,
+					marginCategory
+				);
+			}
+
+			const weightedValue = baseAssetValue
+				.mul(weight)
+				.div(SPOT_MARKET_WEIGHT_PRECISION);
+
+			if (isLiability) {
+				healthComponents.borrows.push({
+					marketIndex: spotMarketAccount.marketIndex,
+					size: netQuoteValue,
+					value: baseAssetValue,
+					weight: weight,
+					weightedValue: weightedValue,
+				});
+			} else {
+				healthComponents.deposits.push({
+					marketIndex: spotMarketAccount.marketIndex,
+					size: netQuoteValue,
+					value: weightedValue,
+					weight: weight,
+					weightedValue: weightedValue,
+				});
+			}
+		}
+
+		return healthComponents;
+	}
+
 	/**
 	 * Get the total position value, excluding any position coming from the given target market
 	 * @param marketToIgnore