@drift-labs/sdk 2.149.0-beta.0 → 2.149.0-beta.1

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;
@@ -190,6 +191,19 @@ class User {
             positionFlag: 0,
         };
     }
+    getIsolatePerpPositionTokenAmount(perpMarketIndex) {
+        var _a;
+        const perpPosition = this.getPerpPosition(perpMarketIndex);
+        if (!perpPosition)
+            return numericConstants_1.ZERO;
+        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)((_a = perpPosition.isolatedPositionScaledBalance) !== null && _a !== void 0 ? _a : numericConstants_1.ZERO, //TODO remove ? later
+        spotMarket, types_2.SpotBalanceType.DEPOSIT);
+    }
     getClonedPosition(position) {
         const clonedPosition = Object.assign({}, position);
         return clonedPosition;
@@ -288,36 +302,73 @@ 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 { totalCollateral, marginRequirement, getIsolatedFreeCollateral } = this.getMarginCalculation(marginCategory, {
+            enteringHighLeverage: enterHighLeverageMode,
+            strict: marginCategory === 'Initial',
+        });
+        if (perpMarketIndex !== undefined) {
+            return getIsolatedFreeCollateral(perpMarketIndex);
+        }
+        else {
+            const freeCollateral = totalCollateral.sub(marginRequirement);
+            return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
+        }
     }
-    /**
-     * @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 liquidationBufferMap = new Map();
+        if (liquidationBuffer && perpMarketIndex !== undefined) {
+            liquidationBufferMap.set(perpMarketIndex, liquidationBuffer);
+        }
+        else if (liquidationBuffer) {
+            liquidationBufferMap.set('cross', liquidationBuffer);
+        }
+        const marginCalc = this.getMarginCalculation(marginCategory, {
+            strict,
+            includeOpenOrders,
+            enteringHighLeverage,
+            liquidationBufferMap,
+        });
+        // If perpMarketIndex is provided, compute only for that market index
+        if (perpMarketIndex !== undefined) {
+            const isolatedMarginCalculation = marginCalc.isolatedMarginCalculations.get(perpMarketIndex);
+            if (!isolatedMarginCalculation)
+                return numericConstants_1.ZERO;
+            const { marginRequirement, marginRequirementPlusBuffer } = isolatedMarginCalculation;
+            if (liquidationBuffer === null || liquidationBuffer === void 0 ? void 0 : liquidationBuffer.gt(numericConstants_1.ZERO)) {
+                return marginRequirementPlusBuffer;
+            }
+            return marginRequirement;
+        }
+        // Default: Cross margin requirement
+        if (liquidationBuffer === null || liquidationBuffer === void 0 ? void 0 : liquidationBuffer.gt(numericConstants_1.ZERO)) {
+            return marginCalc.marginRequirementPlusBuffer;
+        }
+        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, true, 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, false, // 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));
+        return userAccount.perpPositions.filter((pos) => {
+            var _a;
+            return !pos.baseAssetAmount.eq(numericConstants_1.ZERO) ||
+                !pos.quoteAssetAmount.eq(numericConstants_1.ZERO) ||
+                !(pos.openOrders == 0) ||
+                ((_a = pos.isolatedPositionScaledBalance) === null || _a === void 0 ? void 0 : _a.gt(numericConstants_1.ZERO));
+        });
     }
     getActivePerpPositions() {
         const userAccount = this.getUserAccount();
@@ -555,27 +606,72 @@ 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 liquidationBufferMap = (() => {
+            if (liquidationBuffer && perpMarketIndex !== undefined) {
+                return new Map([[perpMarketIndex, liquidationBuffer]]);
+            }
+            else if (liquidationBuffer) {
+                return new Map([['cross', liquidationBuffer]]);
+            }
+            return new Map();
+        })();
+        const marginCalc = this.getMarginCalculation(marginCategory, {
+            strict,
+            includeOpenOrders,
+            liquidationBufferMap,
+        });
+        if (perpMarketIndex !== undefined) {
+            const { totalCollateral, totalCollateralBuffer } = marginCalc.isolatedMarginCalculations.get(perpMarketIndex);
+            if (liquidationBuffer === null || liquidationBuffer === void 0 ? void 0 : liquidationBuffer.gt(numericConstants_1.ZERO)) {
+                return totalCollateralBuffer;
+            }
+            return totalCollateral;
+        }
+        if (liquidationBuffer === null || liquidationBuffer === void 0 ? void 0 : liquidationBuffer.gt(numericConstants_1.ZERO)) {
+            return marginCalc.totalCollateralBuffer;
+        }
+        return marginCalc.totalCollateral;
     }
     getLiquidationBuffer() {
-        // if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
-        let liquidationBuffer = undefined;
+        const liquidationBufferMap = new Map();
         if (this.isBeingLiquidated()) {
-            liquidationBuffer = new anchor_1.BN(this.driftClient.getStateAccount().liquidationMarginBufferRatio);
+            liquidationBufferMap.set('cross', new anchor_1.BN(this.driftClient.getStateAccount().liquidationMarginBufferRatio));
         }
-        return liquidationBuffer;
+        for (const position of this.getActivePerpPositions()) {
+            if (position.positionFlag &
+                (types_2.PositionFlag.BeingLiquidated | types_2.PositionFlag.Bankruptcy)) {
+                liquidationBufferMap.set(position.marketIndex, new anchor_1.BN(this.driftClient.getStateAccount().liquidationMarginBufferRatio));
+            }
+        }
+        return liquidationBufferMap;
     }
     /**
      * calculates User Health by comparing total collateral and maint. margin requirement
      * @returns : number (value from [0, 100])
      */
-    getHealth() {
-        if (this.isBeingLiquidated()) {
+    getHealth(perpMarketIndex) {
+        if (this.isCrossMarginBeingLiquidated() && !perpMarketIndex) {
             return 0;
         }
-        const totalCollateral = this.getTotalCollateral('Maintenance');
-        const maintenanceMarginReq = this.getMaintenanceMarginRequirement();
+        if (perpMarketIndex &&
+            this.isIsolatedPositionBeingLiquidated(perpMarketIndex)) {
+            return 0;
+        }
+        const marginCalc = this.getMarginCalculation('Maintenance');
+        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;
@@ -734,8 +830,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);
@@ -746,7 +842,26 @@ class User {
         }
         return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(netAssetValue);
     }
-    getLeverageComponents(includeOpenOrders = true, marginCategory = undefined) {
+    getLeverageComponents(includeOpenOrders = true, marginCategory = undefined, perpMarketIndex) {
+        var _a;
+        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 tokenAmount = (0, spotBalance_2.getTokenAmount)((_a = perpPosition.isolatedPositionScaledBalance) !== null && _a !== void 0 ? _a : numericConstants_1.ZERO, quoteSpotMarket, types_2.SpotBalanceType.DEPOSIT);
+            const spotAssetValue = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, 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);
@@ -895,21 +1010,96 @@ 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');
+        const isolatedPositions = new Map(Array.from(map.entries())
+            .filter((e) => e[0] !== 'cross')
+            .map(([key, value]) => [key, value]));
+        return cross
+            ? { ...cross, isolatedPositions }
+            : {
+                canBeLiquidated: false,
+                marginRequirement: numericConstants_1.ZERO,
+                totalCollateral: numericConstants_1.ZERO,
+                isolatedPositions,
+            };
+    }
+    /**
+     * 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 liquidationBufferMap = this.getLiquidationBuffer();
+            marginCalc = this.getMarginCalculation('Maintenance', {
+                liquidationBufferMap,
+            });
+        }
+        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.isCrossMarginBeingLiquidated() ||
+            this.hasIsolatedPositionBeingLiquidated());
+    }
+    isCrossMarginBeingLiquidated() {
         return ((this.getUserAccount().status &
             (types_1.UserStatus.BEING_LIQUIDATED | types_1.UserStatus.BANKRUPT)) >
             0);
     }
+    /** Returns true if cross margin is currently below maintenance requirement (no buffer). */
+    canCrossMarginBeLiquidated(marginCalc) {
+        const calc = marginCalc !== null && marginCalc !== void 0 ? marginCalc : this.getMarginCalculation('Maintenance');
+        return calc.totalCollateral.lt(calc.marginRequirement);
+    }
+    hasIsolatedPositionBeingLiquidated() {
+        return this.getActivePerpPositions().some((position) => (position.positionFlag &
+            (types_2.PositionFlag.BeingLiquidated | types_2.PositionFlag.Bankruptcy)) >
+            0);
+    }
+    isIsolatedPositionBeingLiquidated(perpMarketIndex) {
+        const position = this.getActivePerpPositions().find((position) => position.marketIndex === perpMarketIndex);
+        return (((position === null || position === void 0 ? void 0 : position.positionFlag) &
+            (types_2.PositionFlag.BeingLiquidated | types_2.PositionFlag.Bankruptcy)) >
+            0);
+    }
+    /** Returns true if any isolated perp position is currently below its maintenance requirement (no buffer). */
+    getLiquidatableIsolatedPositions(marginCalc) {
+        const liquidatableIsolatedPositions = [];
+        const calc = marginCalc !== null && marginCalc !== void 0 ? marginCalc : this.getMarginCalculation('Maintenance');
+        for (const [marketIndex, isoCalc] of calc.isolatedMarginCalculations) {
+            if (this.canIsolatedPositionMarginBeLiquidated(isoCalc)) {
+                liquidatableIsolatedPositions.push(marketIndex);
+            }
+        }
+        return liquidatableIsolatedPositions;
+    }
+    canIsolatedPositionMarginBeLiquidated(isolatedMarginCalculation) {
+        return isolatedMarginCalculation.totalCollateral.lt(isolatedMarginCalculation.marginRequirement);
+    }
     hasStatus(status) {
         return (this.getUserAccount().status & status) > 0;
     }
@@ -999,14 +1189,38 @@ 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);
+            if (!isolatedMarginCalculation)
+                return new anchor_1.BN(-1);
+            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);
@@ -2004,5 +2218,159 @@ class User {
             activeSpotPositions: activeSpotMarkets,
         };
     }
+    /**
+     * Compute a consolidated margin snapshot once, without caching.
+     * Consumers can use this to avoid duplicating work across separate calls.
+     */
+    getMarginCalculation(marginCategory = 'Initial', opts) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        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 liquidationBufferMap = (_c = opts === null || opts === void 0 ? void 0 : opts.liquidationBufferMap) !== null && _c !== void 0 ? _c : new Map();
+        const includeOpenOrders = (_d = opts === null || opts === void 0 ? void 0 : opts.includeOpenOrders) !== null && _d !== void 0 ? _d : true;
+        // Equivalent to on-chain user_custom_margin_ratio
+        const userCustomMarginRatio = marginCategory === 'Initial' ? this.getUserAccount().maxMarginRatio : 0;
+        // Initialize calc via JS mirror of Rust/on-chain MarginCalculation
+        const isolatedMarginBuffers = new Map();
+        for (const [marketIndex, isolatedMarginBuffer,] of (_e = opts === null || opts === void 0 ? void 0 : opts.liquidationBufferMap) !== null && _e !== void 0 ? _e : new Map()) {
+            if (marketIndex !== 'cross') {
+                isolatedMarginBuffers.set(marketIndex, isolatedMarginBuffer);
+            }
+        }
+        const ctx = marginCalculation_1.MarginContext.standard(marginCategory)
+            .strictMode(strict)
+            .setCrossMarginBuffer((_g = (_f = opts === null || opts === void 0 ? void 0 : opts.liquidationBufferMap) === null || _f === void 0 ? void 0 : _f.get('cross')) !== null && _g !== void 0 ? _g : numericConstants_1.ZERO)
+            .setIsolatedMarginBuffers(isolatedMarginBuffers);
+        const calc = new marginCalculation_1.MarginCalculation(ctx);
+        // SPOT POSITIONS
+        for (const spotPosition of this.getUserAccount().spotPositions) {
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition))
+                continue;
+            const isQuote = spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX;
+            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 (isQuote) {
+                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 weightedTokenValue = this.getSpotAssetValue(tokenAmount, strictOracle, spotMarket, marginCategory);
+                    calc.addCrossMarginTotalCollateral(weightedTokenValue);
+                }
+                else {
+                    // borrow on quote contributes to margin requirement
+                    const tokenValueAbs = this.getSpotLiabilityValue(tokenAmount, strictOracle, spotMarket, marginCategory, (_h = liquidationBufferMap.get('cross')) !== null && _h !== void 0 ? _h : new anchor_1.BN(0)).abs();
+                    calc.addCrossMarginRequirement(tokenValueAbs, tokenValueAbs);
+                }
+                continue;
+            }
+            // Non-quote spot: worst-case simulation
+            const { tokenAmount: worstCaseTokenAmount, ordersValue: worstCaseOrdersValue, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarket, strictOracle, marginCategory, userCustomMarginRatio, includeOpenOrders
+            // false
+            );
+            if (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)) {
+                const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, strictOracle, spotMarket, marginCategory);
+                // asset side increases total collateral (weighted)
+                calc.addCrossMarginTotalCollateral(baseAssetValue);
+            }
+            else if (worstCaseTokenAmount.lt(numericConstants_1.ZERO)) {
+                // liability side increases margin requirement (weighted >= abs(token_value))
+                const getSpotLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount, strictOracle, spotMarket, marginCategory, liquidationBufferMap.get('cross'));
+                calc.addCrossMarginRequirement(getSpotLiabilityValue.abs(), getSpotLiabilityValue.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.getMMOracleDataForPerpMarket(market.marketIndex);
+            const nonMmmOraclePriceData = this.getOracleDataForPerpMarket(market.marketIndex);
+            // Worst-case perp liability and weighted pnl
+            const { worstCaseBaseAssetAmount, worstCaseLiabilityValue } = (0, margin_1.calculateWorstCasePerpLiabilityValue)(marketPosition, market, nonMmmOraclePriceData.price, includeOpenOrders);
+            // margin ratio for this perp
+            const customMarginRatio = Math.max(userCustomMarginRatio, 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
+            if (includeOpenOrders) {
+                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);
+            if (marginCategory !== undefined) {
+                if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                    positionUnrealizedPnl = positionUnrealizedPnl
+                        .mul((0, market_1.calculateUnrealizedAssetWeight)(market, quoteSpotMarket, positionUnrealizedPnl, marginCategory, oraclePriceData))
+                        .div(new anchor_1.BN(numericConstants_1.SPOT_MARKET_WEIGHT_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 ((_j = marketPosition.isolatedPositionScaledBalance) === null || _j === void 0 ? void 0 : _j.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)((_k = marketPosition.isolatedPositionScaledBalance) !== null && _k !== void 0 ? _k : numericConstants_1.ZERO, quoteSpotMarket, types_2.SpotBalanceType.DEPOSIT);
+                    depositValue = (0, spotBalance_1.getStrictTokenValue)(quoteTokenAmount, quoteSpotMarket.decimals, strictQuote);
+                }
+                calc.addIsolatedMarginCalculation(market.marketIndex, depositValue, positionUnrealizedPnl, worstCaseLiabilityValue, perpMarginRequirement);
+                calc.addPerpLiabilityValue(worstCaseLiabilityValue);
+            }
+            else {
+                // cross: add to global requirement and collateral
+                calc.addCrossMarginRequirement(perpMarginRequirement, worstCaseLiabilityValue);
+                calc.addCrossMarginTotalCollateral(positionUnrealizedPnl);
+            }
+        }
+        return calc;
+    }
+    isPerpPositionIsolated(perpPosition) {
+        return (perpPosition.positionFlag & types_2.PositionFlag.IsolatedPosition) !== 0;
+    }
 }
 exports.User = User;

package/lib/node/marginCalculation.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { MarketType } from './types';
+export type MarginCategory = 'Initial' | 'Maintenance' | 'Fill';
+export type MarginCalculationMode = {
+    type: 'Standard';
+} | {
+    type: 'Liquidation';
+};
+export declare class MarketIdentifier {
+    marketType: MarketType;
+    marketIndex: number;
+    private constructor();
+    static spot(marketIndex: number): MarketIdentifier;
+    static perp(marketIndex: number): MarketIdentifier;
+    equals(other: MarketIdentifier | undefined): boolean;
+}
+export declare class MarginContext {
+    marginType: MarginCategory;
+    mode: MarginCalculationMode;
+    strict: boolean;
+    ignoreInvalidDepositOracles: boolean;
+    isolatedMarginBuffers: Map<number, BN>;
+    crossMarginBuffer: BN;
+    private constructor();
+    static standard(marginType: MarginCategory): MarginContext;
+    static liquidation(crossMarginBuffer: BN, isolatedMarginBuffers: Map<number, BN>): MarginContext;
+    strictMode(strict: boolean): this;
+    ignoreInvalidDeposits(ignore: boolean): this;
+    setCrossMarginBuffer(crossMarginBuffer: BN): this;
+    setIsolatedMarginBuffers(isolatedMarginBuffers: Map<number, BN>): this;
+    setIsolatedMarginBuffer(marketIndex: number, isolatedMarginBuffer: BN): this;
+}
+export declare class IsolatedMarginCalculation {
+    marginRequirement: BN;
+    totalCollateral: BN;
+    totalCollateralBuffer: BN;
+    marginRequirementPlusBuffer: BN;
+    constructor();
+    getTotalCollateralPlusBuffer(): BN;
+    meetsMarginRequirement(): boolean;
+    meetsMarginRequirementWithBuffer(): boolean;
+    marginShortage(): BN;
+}
+export declare class MarginCalculation {
+    context: MarginContext;
+    totalCollateral: BN;
+    totalCollateralBuffer: BN;
+    marginRequirement: BN;
+    marginRequirementPlusBuffer: BN;
+    isolatedMarginCalculations: Map<number, IsolatedMarginCalculation>;
+    allDepositOraclesValid: boolean;
+    allLiabilityOraclesValid: boolean;
+    withPerpIsolatedLiability: boolean;
+    withSpotIsolatedLiability: boolean;
+    totalPerpLiabilityValue: BN;
+    trackedMarketMarginRequirement: BN;
+    fuelDeposits: number;
+    fuelBorrows: number;
+    fuelPositions: number;
+    constructor(context: MarginContext);
+    addCrossMarginTotalCollateral(delta: BN): void;
+    addCrossMarginRequirement(marginRequirement: BN, liabilityValue: BN): void;
+    addIsolatedMarginCalculation(marketIndex: number, depositValue: BN, pnl: BN, liabilityValue: BN, marginRequirement: BN): void;
+    addPerpLiabilityValue(perpLiabilityValue: BN): void;
+    updateAllDepositOraclesValid(valid: boolean): void;
+    updateAllLiabilityOraclesValid(valid: boolean): void;
+    updateWithSpotIsolatedLiability(isolated: boolean): void;
+    updateWithPerpIsolatedLiability(isolated: boolean): void;
+    getCrossTotalCollateralPlusBuffer(): BN;
+    meetsCrossMarginRequirement(): boolean;
+    meetsCrossMarginRequirementWithBuffer(): boolean;
+    meetsMarginRequirement(): boolean;
+    meetsMarginRequirementWithBuffer(): boolean;
+    getCrossFreeCollateral(): BN;
+    getIsolatedFreeCollateral(marketIndex: number): BN;
+    getIsolatedMarginCalculation(marketIndex: number): IsolatedMarginCalculation | undefined;
+    hasIsolatedMarginCalculation(marketIndex: number): boolean;
+}
+//# sourceMappingURL=marginCalculation.d.ts.map

package/lib/node/marginCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marginCalculation.d.ts","sourceRoot":"","sources":["../../src/marginCalculation.ts"],"names":[],"mappings":"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"}