@drift-labs/sdk 2.145.0 → 2.146.0-alpha.13

package/lib/browser/user.js

@@ -26,6 +26,7 @@ const tiers_1 = require("./math/tiers");
 const strictOraclePrice_1 = require("./oracles/strictOraclePrice");
 const fuel_1 = require("./math/fuel");
 const grpcUserAccountSubscriber_1 = require("./accounts/grpcUserAccountSubscriber");
+const marginCalculation_1 = require("./marginCalculation");
 class User {
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -186,8 +187,19 @@ class User {
             lastQuoteAssetAmountPerLp: numericConstants_1.ZERO,
             perLpBase: 0,
             maxMarginRatio: 0,
+            positionFlag: 0,
+            isolatedPositionScaledBalance: numericConstants_1.ZERO,
         };
     }
+    getIsolatePerpPositionTokenAmount(perpMarketIndex) {
+        const perpPosition = this.getPerpPosition(perpMarketIndex);
+        const perpMarket = this.driftClient.getPerpMarketAccount(perpMarketIndex);
+        const spotMarket = this.driftClient.getSpotMarketAccount(perpMarket.quoteSpotMarketIndex);
+        if (perpPosition === undefined) {
+            return numericConstants_1.ZERO;
+        }
+        return (0, spotBalance_2.getTokenAmount)(perpPosition.isolatedPositionScaledBalance, spotMarket, types_2.SpotBalanceType.DEPOSIT);
+    }
     getClonedPosition(position) {
         const clonedPosition = Object.assign({}, position);
         return clonedPosition;
@@ -286,36 +298,54 @@ class User {
      * calculates Free Collateral = Total collateral - margin requirement
      * @returns : Precision QUOTE_PRECISION
      */
-    getFreeCollateral(marginCategory = 'Initial', enterHighLeverageMode = undefined) {
-        const totalCollateral = this.getTotalCollateral(marginCategory, true);
-        const marginRequirement = marginCategory === 'Initial'
-            ? this.getInitialMarginRequirement(enterHighLeverageMode)
-            : this.getMaintenanceMarginRequirement();
-        const freeCollateral = totalCollateral.sub(marginRequirement);
-        return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
+    getFreeCollateral(marginCategory = 'Initial', enterHighLeverageMode = false, perpMarketIndex) {
+        const marginCalc = this.getMarginCalculation(marginCategory, {
+            enteringHighLeverage: enterHighLeverageMode,
+        });
+        if (perpMarketIndex !== undefined) {
+            return marginCalc.getIsolatedFreeCollateral(perpMarketIndex);
+        }
+        else {
+            return marginCalc.getCrossFreeCollateral();
+        }
     }
-    /**
-     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
-     */
-    getMarginRequirement(marginCategory, liquidationBuffer, strict = false, includeOpenOrders = true, enteringHighLeverage = undefined) {
-        return this.getTotalPerpPositionLiability(marginCategory, liquidationBuffer, includeOpenOrders, strict, enteringHighLeverage).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, liquidationBuffer, includeOpenOrders, strict));
+    getMarginRequirement(marginCategory, liquidationBuffer, strict, includeOpenOrders, enteringHighLeverage, perpMarketIndex) {
+        const marginCalc = this.getMarginCalculation(marginCategory, {
+            strict,
+            includeOpenOrders,
+            enteringHighLeverage,
+            liquidationBuffer,
+        });
+        // If perpMarketIndex is provided, compute only for that market index
+        if (perpMarketIndex !== undefined) {
+            const isolatedMarginCalculation = marginCalc.isolatedMarginCalculations.get(perpMarketIndex);
+            const { marginRequirement } = isolatedMarginCalculation;
+            return marginRequirement;
+        }
+        // Default: Cross margin requirement
+        // TODO: should we be using plus buffer sometimes?
+        return marginCalc.marginRequirement;
     }
     /**
      * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getInitialMarginRequirement(enterHighLeverageMode = undefined) {
-        return this.getMarginRequirement('Initial', undefined, true, undefined, enterHighLeverageMode);
+    getInitialMarginRequirement(enterHighLeverageMode = false, perpMarketIndex) {
+        return this.getMarginRequirement('Initial', undefined, false, undefined, enterHighLeverageMode, perpMarketIndex);
     }
     /**
      * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
      */
-    getMaintenanceMarginRequirement(liquidationBuffer) {
-        return this.getMarginRequirement('Maintenance', liquidationBuffer);
+    getMaintenanceMarginRequirement(liquidationBuffer, perpMarketIndex) {
+        return this.getMarginRequirement('Maintenance', liquidationBuffer, true, // strict default
+        true, // includeOpenOrders default
+        false, // enteringHighLeverage default
+        perpMarketIndex);
     }
     getActivePerpPositionsForUserAccount(userAccount) {
         return userAccount.perpPositions.filter((pos) => !pos.baseAssetAmount.eq(numericConstants_1.ZERO) ||
             !pos.quoteAssetAmount.eq(numericConstants_1.ZERO) ||
-            !(pos.openOrders == 0));
+            !(pos.openOrders == 0) ||
+            pos.isolatedPositionScaledBalance.gt(numericConstants_1.ZERO));
     }
     getActivePerpPositions() {
         const userAccount = this.getUserAccount();
@@ -353,6 +383,8 @@ class User {
             .filter((pos) => marketIndex !== undefined ? pos.marketIndex === marketIndex : true)
             .reduce((unrealizedPnl, perpPosition) => {
             const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            if (!market)
+                return unrealizedPnl;
             const oraclePriceData = this.getMMOracleDataForPerpMarket(market.marketIndex);
             const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
             const quoteOraclePriceData = this.getOracleDataForSpotMarket(market.quoteSpotMarketIndex);
@@ -553,8 +585,17 @@ class User {
      * calculates TotalCollateral: collateral + unrealized pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getTotalCollateral(marginCategory = 'Initial', strict = false, includeOpenOrders = true, liquidationBuffer) {
-        return this.getSpotMarketAssetValue(undefined, marginCategory, includeOpenOrders, strict).add(this.getUnrealizedPNL(true, undefined, marginCategory, strict, liquidationBuffer));
+    getTotalCollateral(marginCategory = 'Initial', strict = false, includeOpenOrders = true, liquidationBuffer, perpMarketIndex) {
+        const marginCalc = this.getMarginCalculation(marginCategory, {
+            strict,
+            includeOpenOrders,
+            liquidationBuffer,
+        });
+        if (perpMarketIndex !== undefined) {
+            return marginCalc.isolatedMarginCalculations.get(perpMarketIndex)
+                .totalCollateral;
+        }
+        return marginCalc.totalCollateral;
     }
     getLiquidationBuffer() {
         // if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
@@ -568,12 +609,24 @@ class User {
      * calculates User Health by comparing total collateral and maint. margin requirement
      * @returns : number (value from [0, 100])
      */
-    getHealth() {
-        if (this.isBeingLiquidated()) {
+    getHealth(perpMarketIndex) {
+        const marginCalc = this.getMarginCalculation('Maintenance');
+        if (this.isCrossMarginBeingLiquidated(marginCalc) && !perpMarketIndex) {
             return 0;
         }
-        const totalCollateral = this.getTotalCollateral('Maintenance');
-        const maintenanceMarginReq = this.getMaintenanceMarginRequirement();
+        let totalCollateral;
+        let maintenanceMarginReq;
+        if (perpMarketIndex) {
+            const isolatedMarginCalc = marginCalc.isolatedMarginCalculations.get(perpMarketIndex);
+            if (isolatedMarginCalc) {
+                totalCollateral = isolatedMarginCalc.totalCollateral;
+                maintenanceMarginReq = isolatedMarginCalc.marginRequirement;
+            }
+        }
+        else {
+            totalCollateral = marginCalc.totalCollateral;
+            maintenanceMarginReq = marginCalc.marginRequirement;
+        }
         let health;
         if (maintenanceMarginReq.eq(numericConstants_1.ZERO) && totalCollateral.gte(numericConstants_1.ZERO)) {
             health = 100;
@@ -589,6 +642,8 @@ class User {
     }
     calculateWeightedPerpPositionLiability(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, enteringHighLeverage = undefined) {
         const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+        if (!market)
+            return numericConstants_1.ZERO;
         let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
         if ((0, types_1.isVariant)(market.status, 'settlement')) {
             valuationPrice = market.expiryPrice;
@@ -732,8 +787,8 @@ class User {
      * calculates current user leverage which is (total liability size) / (net asset value)
      * @returns : Precision TEN_THOUSAND
      */
-    getLeverage(includeOpenOrders = true) {
-        return this.calculateLeverageFromComponents(this.getLeverageComponents(includeOpenOrders));
+    getLeverage(includeOpenOrders = true, perpMarketIndex) {
+        return this.calculateLeverageFromComponents(this.getLeverageComponents(includeOpenOrders, undefined, perpMarketIndex));
     }
     calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }) {
         const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
@@ -744,7 +799,24 @@ class User {
         }
         return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(netAssetValue);
     }
-    getLeverageComponents(includeOpenOrders = true, marginCategory = undefined) {
+    getLeverageComponents(includeOpenOrders = true, marginCategory = undefined, perpMarketIndex) {
+        if (perpMarketIndex) {
+            const perpPosition = this.getPerpPositionOrEmpty(perpMarketIndex);
+            const perpLiability = this.calculateWeightedPerpPositionLiability(perpPosition, marginCategory, undefined, includeOpenOrders);
+            const perpMarket = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            const oraclePriceData = this.getOracleDataForPerpMarket(perpPosition.marketIndex);
+            const quoteSpotMarket = this.driftClient.getSpotMarketAccount(perpMarket.quoteSpotMarketIndex);
+            const quoteOraclePriceData = this.getOracleDataForSpotMarket(perpMarket.quoteSpotMarketIndex);
+            const strictOracle = new strictOraclePrice_1.StrictOraclePrice(quoteOraclePriceData.price, quoteOraclePriceData.twap);
+            const positionUnrealizedPnl = (0, position_2.calculatePositionPNL)(perpMarket, perpPosition, true, oraclePriceData);
+            const spotAssetValue = (0, spotBalance_1.getStrictTokenValue)(perpPosition.isolatedPositionScaledBalance, quoteSpotMarket.decimals, strictOracle);
+            return {
+                perpLiabilityValue: perpLiability,
+                perpPnl: positionUnrealizedPnl,
+                spotAssetValue,
+                spotLiabilityValue: numericConstants_1.ZERO,
+            };
+        }
         const perpLiability = this.getTotalPerpPositionLiability(marginCategory, undefined, includeOpenOrders);
         const perpPnl = this.getUnrealizedPNL(true, undefined, marginCategory);
         const { totalAssetValue: spotAssetValue, totalLiabilityValue: spotLiabilityValue, } = this.getSpotMarketAssetAndLiabilityValue(undefined, marginCategory, undefined, includeOpenOrders);
@@ -893,20 +965,78 @@ class User {
         return netAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
     }
     canBeLiquidated() {
-        const liquidationBuffer = this.getLiquidationBuffer();
-        const totalCollateral = this.getTotalCollateral('Maintenance', undefined, undefined, liquidationBuffer);
-        const marginRequirement = this.getMaintenanceMarginRequirement(liquidationBuffer);
-        const canBeLiquidated = totalCollateral.lt(marginRequirement);
-        return {
-            canBeLiquidated,
-            marginRequirement,
-            totalCollateral,
-        };
+        // Deprecated signature retained for backward compatibility in type only
+        // but implementation now delegates to the new Map-based API and returns cross margin status.
+        const map = this.getLiquidationStatuses();
+        const cross = map.get('cross');
+        return cross
+            ? { ...cross, liquidationStatuses: map }
+            : {
+                canBeLiquidated: false,
+                marginRequirement: numericConstants_1.ZERO,
+                totalCollateral: numericConstants_1.ZERO,
+                liquidationStatuses: map,
+            };
+    }
+    /**
+     * New API: Returns liquidation status for cross and each isolated perp position.
+     * Map keys:
+     *  - 'cross' for cross margin
+     *  - marketIndex (number) for each isolated perp position
+     */
+    getLiquidationStatuses(marginCalc) {
+        // If not provided, use buffer-aware calc for canBeLiquidated checks
+        if (!marginCalc) {
+            const liquidationBuffer = this.getLiquidationBuffer();
+            marginCalc = this.getMarginCalculation('Maintenance', {
+                liquidationBuffer,
+            });
+        }
+        const result = new Map();
+        // Cross margin status
+        const crossTotalCollateral = marginCalc.totalCollateral;
+        const crossMarginRequirement = marginCalc.marginRequirement;
+        result.set('cross', {
+            canBeLiquidated: crossTotalCollateral.lt(crossMarginRequirement),
+            marginRequirement: crossMarginRequirement,
+            totalCollateral: crossTotalCollateral,
+        });
+        // Isolated positions status
+        for (const [marketIndex, isoCalc,] of marginCalc.isolatedMarginCalculations) {
+            const isoTotalCollateral = isoCalc.totalCollateral;
+            const isoMarginRequirement = isoCalc.marginRequirement;
+            result.set(marketIndex, {
+                canBeLiquidated: isoTotalCollateral.lt(isoMarginRequirement),
+                marginRequirement: isoMarginRequirement,
+                totalCollateral: isoTotalCollateral,
+            });
+        }
+        return result;
     }
-    isBeingLiquidated() {
-        return ((this.getUserAccount().status &
+    isBeingLiquidated(marginCalc) {
+        // Consider on-chain flags OR computed margin status (cross or any isolated)
+        const hasOnChainFlag = (this.getUserAccount().status &
             (types_1.UserStatus.BEING_LIQUIDATED | types_1.UserStatus.BANKRUPT)) >
-            0);
+            0;
+        const calc = marginCalc !== null && marginCalc !== void 0 ? marginCalc : this.getMarginCalculation('Maintenance');
+        return (hasOnChainFlag ||
+            this.isCrossMarginBeingLiquidated(calc) ||
+            this.isIsolatedMarginBeingLiquidated(calc));
+    }
+    /** Returns true if cross margin is currently below maintenance requirement (no buffer). */
+    isCrossMarginBeingLiquidated(marginCalc) {
+        const calc = marginCalc !== null && marginCalc !== void 0 ? marginCalc : this.getMarginCalculation('Maintenance');
+        return calc.totalCollateral.lt(calc.marginRequirement);
+    }
+    /** Returns true if any isolated perp position is currently below its maintenance requirement (no buffer). */
+    isIsolatedMarginBeingLiquidated(marginCalc) {
+        const calc = marginCalc !== null && marginCalc !== void 0 ? marginCalc : this.getMarginCalculation('Maintenance');
+        for (const [, isoCalc] of calc.isolatedMarginCalculations) {
+            if (isoCalc.totalCollateral.lt(isoCalc.marginRequirement)) {
+                return true;
+            }
+        }
+        return false;
     }
     hasStatus(status) {
         return (this.getUserAccount().status & status) > 0;
@@ -997,14 +1127,36 @@ class User {
      * @param offsetCollateral // allows calculating the liquidation price after this offset collateral is added to the user's account (e.g. : what will the liquidation price be for this position AFTER I deposit $x worth of collateral)
      * @returns Precision : PRICE_PRECISION
      */
-    liquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO, estimatedEntryPrice = numericConstants_1.ZERO, marginCategory = 'Maintenance', includeOpenOrders = false, offsetCollateral = numericConstants_1.ZERO, enteringHighLeverage = undefined) {
-        const totalCollateral = this.getTotalCollateral(marginCategory, false, includeOpenOrders);
-        const marginRequirement = this.getMarginRequirement(marginCategory, undefined, false, includeOpenOrders, enteringHighLeverage);
-        let freeCollateral = anchor_1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(marginRequirement)).add(offsetCollateral);
+    liquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO, estimatedEntryPrice = numericConstants_1.ZERO, marginCategory = 'Maintenance', includeOpenOrders = false, offsetCollateral = numericConstants_1.ZERO, enteringHighLeverage = false, marginType) {
+        const market = this.driftClient.getPerpMarketAccount(marketIndex);
         const oracle = this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
         const oraclePrice = this.driftClient.getOracleDataForPerpMarket(marketIndex).price;
-        const market = this.driftClient.getPerpMarketAccount(marketIndex);
         const currentPerpPosition = this.getPerpPositionOrEmpty(marketIndex);
+        if (marginType === 'Isolated') {
+            const marginCalculation = this.getMarginCalculation(marginCategory, {
+                strict: false,
+                includeOpenOrders,
+                enteringHighLeverage,
+            });
+            const isolatedMarginCalculation = marginCalculation.isolatedMarginCalculations.get(marketIndex);
+            const { totalCollateral, marginRequirement } = isolatedMarginCalculation;
+            const freeCollateral = anchor_1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(marginRequirement)).add(offsetCollateral);
+            const freeCollateralDelta = this.calculateFreeCollateralDeltaForPerp(market, currentPerpPosition, positionBaseSizeChange, oraclePrice, marginCategory, includeOpenOrders, enteringHighLeverage);
+            if (freeCollateralDelta.eq(numericConstants_1.ZERO)) {
+                return new anchor_1.BN(-1);
+            }
+            const liqPriceDelta = freeCollateral
+                .mul(numericConstants_1.QUOTE_PRECISION)
+                .div(freeCollateralDelta);
+            const liqPrice = oraclePrice.sub(liqPriceDelta);
+            if (liqPrice.lt(numericConstants_1.ZERO)) {
+                return new anchor_1.BN(-1);
+            }
+            return liqPrice;
+        }
+        const totalCollateral = this.getTotalCollateral(marginCategory, false, includeOpenOrders);
+        const marginRequirement = this.getMarginRequirement(marginCategory, undefined, false, includeOpenOrders, enteringHighLeverage);
+        let freeCollateral = anchor_1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(marginRequirement)).add(offsetCollateral);
         positionBaseSizeChange = (0, orders_1.standardizeBaseAssetAmount)(positionBaseSizeChange, market.amm.orderStepSize);
         const freeCollateralChangeFromNewPosition = this.calculateEntriesEffectOnFreeCollateral(market, oraclePrice, currentPerpPosition, positionBaseSizeChange, estimatedEntryPrice, includeOpenOrders, enteringHighLeverage);
         freeCollateral = freeCollateral.add(freeCollateralChangeFromNewPosition);
@@ -2002,5 +2154,158 @@ class User {
             activeSpotPositions: activeSpotMarkets,
         };
     }
+    /**
+     * Compute a consolidated margin snapshot once, without caching.
+     * Consumers can use this to avoid duplicating work across separate calls.
+     */
+    // TODO: need another param to tell it give it back leverage compnents
+    // TODO: change get leverage functions need to pull the right values from
+    getMarginCalculation(marginCategory = 'Initial', opts) {
+        var _a, _b, _c;
+        const strict = (_a = opts === null || opts === void 0 ? void 0 : opts.strict) !== null && _a !== void 0 ? _a : false;
+        const enteringHighLeverage = (_b = opts === null || opts === void 0 ? void 0 : opts.enteringHighLeverage) !== null && _b !== void 0 ? _b : false;
+        const includeOpenOrders = (_c = opts === null || opts === void 0 ? void 0 : opts.includeOpenOrders) !== null && _c !== void 0 ? _c : true; // TODO: remove this ??
+        const marginBuffer = opts === null || opts === void 0 ? void 0 : opts.liquidationBuffer; // treat as MARGIN_BUFFER ratio if provided
+        const marginRatioOverride = opts === null || opts === void 0 ? void 0 : opts.marginRatioOverride;
+        // Equivalent to on-chain user_custom_margin_ratio
+        let userCustomMarginRatio = marginCategory === 'Initial' ? this.getUserAccount().maxMarginRatio : 0;
+        if (marginRatioOverride !== undefined) {
+            userCustomMarginRatio = Math.max(userCustomMarginRatio, marginRatioOverride);
+        }
+        // Initialize calc via JS mirror of Rust MarginCalculation
+        const ctx = marginCalculation_1.MarginContext.standard(marginCategory)
+            .strictMode(strict)
+            .setMarginBuffer(marginBuffer)
+            .setMarginRatioOverride(userCustomMarginRatio);
+        const calc = new marginCalculation_1.MarginCalculation(ctx);
+        // SPOT POSITIONS
+        // TODO: include open orders in the worst-case simulation in the same way on both spot and perp positions
+        for (const spotPosition of this.getUserAccount().spotPositions) {
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition))
+                continue;
+            const spotMarket = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            const twap5 = strict
+                ? (0, oracles_1.calculateLiveOracleTwap)(spotMarket.historicalOracleData, oraclePriceData, new anchor_1.BN(Math.floor(Date.now() / 1000)), numericConstants_1.FIVE_MINUTE)
+                : undefined;
+            const strictOracle = new strictOraclePrice_1.StrictOraclePrice(oraclePriceData.price, twap5);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_2.getTokenAmount)(spotPosition.scaledBalance, spotMarket, spotPosition.balanceType), spotPosition.balanceType);
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'deposit')) {
+                    // add deposit value to total collateral
+                    const tokenValue = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, spotMarket.decimals, strictOracle);
+                    calc.addCrossMarginTotalCollateral(tokenValue);
+                }
+                else {
+                    // borrow on quote contributes to margin requirement
+                    const tokenValueAbs = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, spotMarket.decimals, strictOracle).abs();
+                    calc.addCrossMarginRequirement(tokenValueAbs, tokenValueAbs);
+                    calc.addSpotLiability();
+                }
+                continue;
+            }
+            // Non-quote spot: worst-case simulation
+            const { tokenAmount: worstCaseTokenAmount, ordersValue: worstCaseOrdersValue, tokenValue: worstCaseTokenValue, weightedTokenValue: worstCaseWeightedTokenValue, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarket, strictOracle, marginCategory, userCustomMarginRatio, includeOpenOrders);
+            // open order IM
+            calc.addCrossMarginRequirement(new anchor_1.BN(spotPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT), numericConstants_1.ZERO);
+            if (worstCaseTokenAmount.gt(numericConstants_1.ZERO)) {
+                // asset side increases total collateral (weighted)
+                calc.addCrossMarginTotalCollateral(worstCaseWeightedTokenValue);
+            }
+            else if (worstCaseTokenAmount.lt(numericConstants_1.ZERO)) {
+                // liability side increases margin requirement (weighted >= abs(token_value))
+                const liabilityWeighted = worstCaseWeightedTokenValue.abs();
+                calc.addCrossMarginRequirement(liabilityWeighted, worstCaseTokenValue.abs());
+                calc.addSpotLiability();
+                calc.addSpotLiabilityValue(worstCaseTokenValue.abs());
+            }
+            else if (spotPosition.openOrders !== 0) {
+                calc.addSpotLiability();
+                calc.addSpotLiabilityValue(worstCaseTokenValue.abs());
+            }
+            // orders value contributes to collateral or requirement
+            if (worstCaseOrdersValue.gt(numericConstants_1.ZERO)) {
+                calc.addCrossMarginTotalCollateral(worstCaseOrdersValue);
+            }
+            else if (worstCaseOrdersValue.lt(numericConstants_1.ZERO)) {
+                const absVal = worstCaseOrdersValue.abs();
+                calc.addCrossMarginRequirement(absVal, absVal);
+            }
+        }
+        // PERP POSITIONS
+        for (const marketPosition of this.getActivePerpPositions()) {
+            const market = this.driftClient.getPerpMarketAccount(marketPosition.marketIndex);
+            const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
+            const quoteOraclePriceData = this.getOracleDataForSpotMarket(market.quoteSpotMarketIndex);
+            const oraclePriceData = this.getOracleDataForPerpMarket(market.marketIndex);
+            // Worst-case perp liability and weighted pnl
+            const { worstCaseBaseAssetAmount, worstCaseLiabilityValue } = (0, margin_1.calculateWorstCasePerpLiabilityValue)(marketPosition, market, oraclePriceData.price, includeOpenOrders);
+            // margin ratio for this perp
+            const customMarginRatio = Math.max(this.getUserAccount().maxMarginRatio, marketPosition.maxMarginRatio);
+            let marginRatio = new anchor_1.BN((0, market_1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), marginCategory, customMarginRatio, this.isHighLeverageMode(marginCategory) || enteringHighLeverage));
+            if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                marginRatio = numericConstants_1.ZERO;
+            }
+            // convert liability to quote value and apply margin ratio
+            const quotePrice = strict
+                ? anchor_1.BN.max(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min)
+                : quoteOraclePriceData.price;
+            let perpMarginRequirement = worstCaseLiabilityValue
+                .mul(quotePrice)
+                .div(numericConstants_1.PRICE_PRECISION)
+                .mul(marginRatio)
+                .div(numericConstants_1.MARGIN_PRECISION);
+            // add open orders IM
+            perpMarginRequirement = perpMarginRequirement.add(new anchor_1.BN(marketPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+            // weighted unrealized pnl
+            let positionUnrealizedPnl = (0, position_2.calculatePositionPNL)(market, marketPosition, true, oraclePriceData);
+            let pnlQuotePrice;
+            if (strict && positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                pnlQuotePrice = anchor_1.BN.min(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min);
+            }
+            else if (strict && positionUnrealizedPnl.lt(numericConstants_1.ZERO)) {
+                pnlQuotePrice = anchor_1.BN.max(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min);
+            }
+            else {
+                pnlQuotePrice = quoteOraclePriceData.price;
+            }
+            positionUnrealizedPnl = positionUnrealizedPnl
+                .mul(pnlQuotePrice)
+                .div(numericConstants_1.PRICE_PRECISION);
+            // Add perp contribution: isolated vs cross
+            const isIsolated = this.isPerpPositionIsolated(marketPosition);
+            if (isIsolated) {
+                // derive isolated quote deposit value, mirroring on-chain logic
+                let depositValue = numericConstants_1.ZERO;
+                if (marketPosition.isolatedPositionScaledBalance.gt(numericConstants_1.ZERO)) {
+                    const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
+                    const quoteOraclePriceData = this.getOracleDataForSpotMarket(market.quoteSpotMarketIndex);
+                    const strictQuote = new strictOraclePrice_1.StrictOraclePrice(quoteOraclePriceData.price, strict
+                        ? quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
+                        : undefined);
+                    const quoteTokenAmount = (0, spotBalance_2.getTokenAmount)(marketPosition.isolatedPositionScaledBalance, quoteSpotMarket, types_2.SpotBalanceType.DEPOSIT);
+                    depositValue = (0, spotBalance_1.getStrictTokenValue)(quoteTokenAmount, quoteSpotMarket.decimals, strictQuote);
+                }
+                calc.addIsolatedMarginCalculation(market.marketIndex, depositValue, positionUnrealizedPnl, worstCaseLiabilityValue, perpMarginRequirement);
+                calc.addPerpLiability();
+                calc.addPerpLiabilityValue(worstCaseLiabilityValue);
+            }
+            else {
+                // cross: add to global requirement and collateral
+                calc.addCrossMarginRequirement(perpMarginRequirement, worstCaseLiabilityValue);
+                calc.addCrossMarginTotalCollateral(positionUnrealizedPnl);
+                const hasPerpLiability = !marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
+                    marketPosition.quoteAssetAmount.lt(numericConstants_1.ZERO) ||
+                    marketPosition.openOrders !== 0;
+                if (hasPerpLiability) {
+                    calc.addPerpLiability();
+                }
+            }
+        }
+        return calc;
+    }
+    isPerpPositionIsolated(perpPosition) {
+        return (perpPosition.positionFlag & types_2.PositionFlag.IsolatedPosition) !== 0;
+    }
 }
 exports.User = User;

package/lib/node/accounts/grpcMultiUserAccountSubscriber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grpcMultiUserAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/grpcMultiUserAccountSubscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,WAAW,EAEX,SAAS,EAET,qBAAqB,EACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAW,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,qBAAa,8BAA8B;IAC1C,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,eAAe,CAA0C;IAEjE,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,SAAS,CAGb;IACJ,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,sBAAsB,CAA4C;IAC1E,OAAO,CAAC,WAAW,CAAc;IACjC,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB,OAAO,CAAC,mBAAmB,CAgBzB;gBAGD,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,SAAS,CAAC,EAAE,SAAS,EACrB,eAAe,CAAC,EAAE,0BAA0B,CAAC,WAAW,CAAC;IAQ7C,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IA0ChC,OAAO,CAAC,oBAAoB,EAAE,SAAS,GAAG,qBAAqB;IA8FtE,OAAO,CAAC,aAAa;YAOP,YAAY;CAmE1B"}
+{"version":3,"file":"grpcMultiUserAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/grpcMultiUserAccountSubscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,WAAW,EAEX,SAAS,EAET,qBAAqB,EACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAW,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,qBAAa,8BAA8B;IAC1C,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,eAAe,CAA0C;IAEjE,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,SAAS,CAGb;IACJ,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,sBAAsB,CAA4C;IAC1E,OAAO,CAAC,WAAW,CAAc;IACjC,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB,OAAO,CAAC,mBAAmB,CAgBzB;gBAGD,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,SAAS,CAAC,EAAE,SAAS,EACrB,eAAe,CAAC,EAAE,0BAA0B,CAAC,WAAW,CAAC;IAQ7C,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IA0ChC,OAAO,CAAC,oBAAoB,EAAE,SAAS,GAAG,qBAAqB;IAqGtE,OAAO,CAAC,aAAa;YAOP,YAAY;CAmE1B"}

package/lib/node/accounts/grpcMultiUserAccountSubscriber.js

@@ -76,7 +76,10 @@ class grpcMultiUserAccountSubscriber {
                 this.listeners.set(key, new Set());
                 this.keyToPk.set(key, userAccountPublicKey);
                 this.pendingAddKeys.add(key);
-                this.scheduleFlush();
+                if (this.isMultiSubscribed) {
+                    // only schedule flush if already subscribed to the multi-subscriber
+                    this.scheduleFlush();
+                }
             }
         };
         const perUser = {
@@ -110,6 +113,10 @@ class grpcMultiUserAccountSubscriber {
                 this.updateData(account, 0);
             },
             updateData(userAccount, slot) {
+                const existingData = parent.userData.get(key);
+                if (existingData && existingData.slot > slot) {
+                    return;
+                }
                 parent.userData.set(key, { data: userAccount, slot });
                 perUserEmitter.emit('userAccountUpdate', userAccount);
                 perUserEmitter.emit('update');