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

package/lib/browser/marginCalculation.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarginCalculation = exports.IsolatedMarginCalculation = exports.MarginContext = exports.MarketIdentifier = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("./constants/numericConstants");
+const types_1 = require("./types");
+class MarketIdentifier {
+    constructor(marketType, marketIndex) {
+        this.marketType = marketType;
+        this.marketIndex = marketIndex;
+    }
+    static spot(marketIndex) {
+        return new MarketIdentifier(types_1.MarketType.SPOT, marketIndex);
+    }
+    static perp(marketIndex) {
+        return new MarketIdentifier(types_1.MarketType.PERP, marketIndex);
+    }
+    equals(other) {
+        return (!!other &&
+            this.marketType === other.marketType &&
+            this.marketIndex === other.marketIndex);
+    }
+}
+exports.MarketIdentifier = MarketIdentifier;
+class MarginContext {
+    constructor(marginType) {
+        this.marginType = marginType;
+        this.mode = { type: 'Standard' };
+        this.strict = false;
+        this.ignoreInvalidDepositOracles = false;
+        this.marginBuffer = new anchor_1.BN(0);
+    }
+    static standard(marginType) {
+        return new MarginContext(marginType);
+    }
+    static liquidation(marginBuffer) {
+        const ctx = new MarginContext('Maintenance');
+        ctx.mode = { type: 'Liquidation' };
+        ctx.marginBuffer = marginBuffer !== null && marginBuffer !== void 0 ? marginBuffer : new anchor_1.BN(0);
+        return ctx;
+    }
+    strictMode(strict) {
+        this.strict = strict;
+        return this;
+    }
+    ignoreInvalidDeposits(ignore) {
+        this.ignoreInvalidDepositOracles = ignore;
+        return this;
+    }
+    setMarginBuffer(buffer) {
+        this.marginBuffer = buffer !== null && buffer !== void 0 ? buffer : new anchor_1.BN(0);
+        return this;
+    }
+    setMarginRatioOverride(ratio) {
+        this.marginRatioOverride = ratio;
+        return this;
+    }
+}
+exports.MarginContext = MarginContext;
+class IsolatedMarginCalculation {
+    constructor() {
+        this.marginRequirement = new anchor_1.BN(0);
+        this.totalCollateral = new anchor_1.BN(0);
+        this.totalCollateralBuffer = new anchor_1.BN(0);
+        this.marginRequirementPlusBuffer = new anchor_1.BN(0);
+    }
+    getTotalCollateralPlusBuffer() {
+        return this.totalCollateral.add(this.totalCollateralBuffer);
+    }
+    meetsMarginRequirement() {
+        return this.totalCollateral.gte(this.marginRequirement);
+    }
+    meetsMarginRequirementWithBuffer() {
+        return this.getTotalCollateralPlusBuffer().gte(this.marginRequirementPlusBuffer);
+    }
+    marginShortage() {
+        const shortage = this.marginRequirementPlusBuffer.sub(this.getTotalCollateralPlusBuffer());
+        return shortage.isNeg() ? new anchor_1.BN(0) : shortage;
+    }
+}
+exports.IsolatedMarginCalculation = IsolatedMarginCalculation;
+class MarginCalculation {
+    constructor(context) {
+        this.context = context;
+        this.totalCollateral = new anchor_1.BN(0);
+        this.totalCollateralBuffer = new anchor_1.BN(0);
+        this.marginRequirement = new anchor_1.BN(0);
+        this.marginRequirementPlusBuffer = new anchor_1.BN(0);
+        this.isolatedMarginCalculations = new Map();
+        this.numSpotLiabilities = 0;
+        this.numPerpLiabilities = 0;
+        this.allDepositOraclesValid = true;
+        this.allLiabilityOraclesValid = true;
+        this.withPerpIsolatedLiability = false;
+        this.withSpotIsolatedLiability = false;
+        this.totalSpotLiabilityValue = new anchor_1.BN(0);
+        this.totalPerpLiabilityValue = new anchor_1.BN(0);
+        this.trackedMarketMarginRequirement = new anchor_1.BN(0);
+        this.fuelDeposits = 0;
+        this.fuelBorrows = 0;
+        this.fuelPositions = 0;
+    }
+    addCrossMarginTotalCollateral(delta) {
+        this.totalCollateral = this.totalCollateral.add(delta);
+        if (this.context.marginBuffer.gt(new anchor_1.BN(0)) && delta.isNeg()) {
+            this.totalCollateralBuffer = this.totalCollateralBuffer.add(delta.mul(this.context.marginBuffer).div(numericConstants_1.MARGIN_PRECISION));
+        }
+    }
+    addCrossMarginRequirement(marginRequirement, liabilityValue) {
+        this.marginRequirement = this.marginRequirement.add(marginRequirement);
+        if (this.context.marginBuffer.gt(new anchor_1.BN(0))) {
+            this.marginRequirementPlusBuffer = this.marginRequirementPlusBuffer.add(marginRequirement.add(liabilityValue.mul(this.context.marginBuffer).div(numericConstants_1.MARGIN_PRECISION)));
+        }
+    }
+    addIsolatedMarginCalculation(marketIndex, depositValue, pnl, liabilityValue, marginRequirement) {
+        const totalCollateral = depositValue.add(pnl);
+        const totalCollateralBuffer = this.context.marginBuffer.gt(new anchor_1.BN(0)) && pnl.isNeg()
+            ? pnl.mul(this.context.marginBuffer).div(numericConstants_1.MARGIN_PRECISION)
+            : new anchor_1.BN(0);
+        const marginRequirementPlusBuffer = this.context.marginBuffer.gt(new anchor_1.BN(0))
+            ? marginRequirement.add(liabilityValue.mul(this.context.marginBuffer).div(numericConstants_1.MARGIN_PRECISION))
+            : new anchor_1.BN(0);
+        const iso = new IsolatedMarginCalculation();
+        iso.marginRequirement = marginRequirement;
+        iso.totalCollateral = totalCollateral;
+        iso.totalCollateralBuffer = totalCollateralBuffer;
+        iso.marginRequirementPlusBuffer = marginRequirementPlusBuffer;
+        this.isolatedMarginCalculations.set(marketIndex, iso);
+    }
+    addSpotLiability() {
+        this.numSpotLiabilities += 1;
+    }
+    addPerpLiability() {
+        this.numPerpLiabilities += 1;
+    }
+    addSpotLiabilityValue(spotLiabilityValue) {
+        this.totalSpotLiabilityValue =
+            this.totalSpotLiabilityValue.add(spotLiabilityValue);
+    }
+    addPerpLiabilityValue(perpLiabilityValue) {
+        this.totalPerpLiabilityValue =
+            this.totalPerpLiabilityValue.add(perpLiabilityValue);
+    }
+    updateAllDepositOraclesValid(valid) {
+        this.allDepositOraclesValid = this.allDepositOraclesValid && valid;
+    }
+    updateAllLiabilityOraclesValid(valid) {
+        this.allLiabilityOraclesValid = this.allLiabilityOraclesValid && valid;
+    }
+    updateWithSpotIsolatedLiability(isolated) {
+        this.withSpotIsolatedLiability = this.withSpotIsolatedLiability || isolated;
+    }
+    updateWithPerpIsolatedLiability(isolated) {
+        this.withPerpIsolatedLiability = this.withPerpIsolatedLiability || isolated;
+    }
+    validateNumSpotLiabilities() {
+        if (this.numSpotLiabilities > 0 && this.marginRequirement.eq(new anchor_1.BN(0))) {
+            throw new Error('InvalidMarginRatio: num_spot_liabilities>0 but margin_requirement=0');
+        }
+    }
+    getNumOfLiabilities() {
+        return this.numSpotLiabilities + this.numPerpLiabilities;
+    }
+    getCrossTotalCollateralPlusBuffer() {
+        return this.totalCollateral.add(this.totalCollateralBuffer);
+    }
+    meetsCrossMarginRequirement() {
+        return this.totalCollateral.gte(this.marginRequirement);
+    }
+    meetsCrossMarginRequirementWithBuffer() {
+        return this.getCrossTotalCollateralPlusBuffer().gte(this.marginRequirementPlusBuffer);
+    }
+    meetsMarginRequirement() {
+        if (!this.meetsCrossMarginRequirement())
+            return false;
+        for (const [, iso] of this.isolatedMarginCalculations) {
+            if (!iso.meetsMarginRequirement())
+                return false;
+        }
+        return true;
+    }
+    meetsMarginRequirementWithBuffer() {
+        if (!this.meetsCrossMarginRequirementWithBuffer())
+            return false;
+        for (const [, iso] of this.isolatedMarginCalculations) {
+            if (!iso.meetsMarginRequirementWithBuffer())
+                return false;
+        }
+        return true;
+    }
+    getCrossFreeCollateral() {
+        const free = this.totalCollateral.sub(this.marginRequirement);
+        return free.isNeg() ? new anchor_1.BN(0) : free;
+    }
+    getIsolatedFreeCollateral(marketIndex) {
+        const iso = this.isolatedMarginCalculations.get(marketIndex);
+        if (!iso)
+            throw new Error('InvalidMarginCalculation: missing isolated calc');
+        const free = iso.totalCollateral.sub(iso.marginRequirement);
+        return free.isNeg() ? new anchor_1.BN(0) : free;
+    }
+    getIsolatedMarginCalculation(marketIndex) {
+        return this.isolatedMarginCalculations.get(marketIndex);
+    }
+    hasIsolatedMarginCalculation(marketIndex) {
+        return this.isolatedMarginCalculations.has(marketIndex);
+    }
+}
+exports.MarginCalculation = MarginCalculation;

package/lib/browser/math/margin.d.ts

@@ -19,7 +19,7 @@ export declare function calculateOraclePriceForPerpMargin(perpPosition: PerpPosi
  */
 export declare function calculateBaseAssetValueWithOracle(market: PerpMarketAccount, perpPosition: PerpPosition, oraclePriceData: Pick<OraclePriceData, 'price'>, includeOpenOrders?: boolean): BN;
 export declare function calculateWorstCaseBaseAssetAmount(perpPosition: PerpPosition, perpMarket: PerpMarketAccount, oraclePrice: BN): BN;
-export declare function calculateWorstCasePerpLiabilityValue(perpPosition: PerpPosition, perpMarket: PerpMarketAccount, oraclePrice: BN): {
+export declare function calculateWorstCasePerpLiabilityValue(perpPosition: PerpPosition, perpMarket: PerpMarketAccount, oraclePrice: BN, includeOpenOrders?: boolean): {
     worstCaseBaseAssetAmount: BN;
     worstCaseLiabilityValue: BN;
 };

package/lib/browser/math/margin.js

@@ -89,7 +89,14 @@ function calculateWorstCaseBaseAssetAmount(perpPosition, perpMarket, oraclePrice
     return calculateWorstCasePerpLiabilityValue(perpPosition, perpMarket, oraclePrice).worstCaseBaseAssetAmount;
 }
 exports.calculateWorstCaseBaseAssetAmount = calculateWorstCaseBaseAssetAmount;
-function calculateWorstCasePerpLiabilityValue(perpPosition, perpMarket, oraclePrice) {
+function calculateWorstCasePerpLiabilityValue(perpPosition, perpMarket, oraclePrice, includeOpenOrders = true) {
+    // return early if no open orders required
+    if (!includeOpenOrders) {
+        return {
+            worstCaseBaseAssetAmount: perpPosition.baseAssetAmount,
+            worstCaseLiabilityValue: calculatePerpLiabilityValue(perpPosition.baseAssetAmount, oraclePrice, (0, types_1.isVariant)(perpMarket.contractType, 'prediction')),
+        };
+    }
     const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
     const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
     const isPredictionMarket = (0, types_1.isVariant)(perpMarket.contractType, 'prediction');

package/lib/browser/math/position.d.ts

@@ -46,6 +46,7 @@ export declare function calculateUnsettledFundingPnl(market: PerpMarketAccount,
  */
 export declare function calculatePositionFundingPNL(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
 export declare function positionIsAvailable(position: PerpPosition): boolean;
+export declare function positionIsBeingLiquidated(position: PerpPosition): boolean;
 /**
  *
  * @param userPosition

package/lib/browser/math/position.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOpenOrders = exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.calculateBreakEvenPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledFundingPnl = exports.calculateFeesAndFundingPnl = exports.calculateClaimablePnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.hasOpenOrders = exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.calculateBreakEvenPrice = exports.positionIsBeingLiquidated = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledFundingPnl = exports.calculateFeesAndFundingPnl = exports.calculateClaimablePnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -149,9 +149,17 @@ function positionIsAvailable(position) {
     return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
         position.openOrders === 0 &&
         position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
-        position.lpShares.eq(numericConstants_1.ZERO));
+        position.lpShares.eq(numericConstants_1.ZERO) &&
+        position.isolatedPositionScaledBalance.eq(numericConstants_1.ZERO) &&
+        !positionIsBeingLiquidated(position));
 }
 exports.positionIsAvailable = positionIsAvailable;
+function positionIsBeingLiquidated(position) {
+    return ((position.positionFlag &
+        (types_1.PositionFlag.BeingLiquidated | types_1.PositionFlag.Bankruptcy)) >
+        0);
+}
+exports.positionIsBeingLiquidated = positionIsBeingLiquidated;
 /**
  *
  * @param userPosition

package/lib/browser/math/spotPosition.d.ts

@@ -11,7 +11,7 @@ export type OrderFillSimulation = {
     weightedTokenValue: BN;
     freeCollateralContribution: any;
 };
-export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, strictOraclePrice: StrictOraclePrice, marginCategory: MarginCategory, customMarginRatio?: number): OrderFillSimulation;
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, strictOraclePrice: StrictOraclePrice, marginCategory: MarginCategory, customMarginRatio?: number, includeOpenOrders?: boolean): OrderFillSimulation;
 export declare function calculateWeightedTokenValue(tokenAmount: BN, tokenValue: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory, customMarginRatio?: number): {
     weight: BN;
     weightedTokenValue: BN;

package/lib/browser/math/spotPosition.js

@@ -8,10 +8,11 @@ function isSpotPositionAvailable(position) {
     return position.scaledBalance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
-function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, customMarginRatio) {
+function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, customMarginRatio, includeOpenOrders = true) {
     const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     const tokenValue = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
-    if (spotPosition.openBids.eq(numericConstants_1.ZERO) && spotPosition.openAsks.eq(numericConstants_1.ZERO)) {
+    if ((spotPosition.openBids.eq(numericConstants_1.ZERO) && spotPosition.openAsks.eq(numericConstants_1.ZERO)) ||
+        !includeOpenOrders) {
         const { weight, weightedTokenValue } = calculateWeightedTokenValue(tokenAmount, tokenValue, strictOraclePrice.current, spotMarketAccount, marginCategory, customMarginRatio);
         return {
             tokenAmount,

package/lib/browser/math/superStake.d.ts

@@ -5,6 +5,7 @@ import { DriftClient } from '../driftClient';
 import { BN } from '@coral-xyz/anchor';
 import { User } from '../user';
 import { DepositRecord } from '../types';
+import fetch from 'node-fetch';
 export type BSOL_STATS_API_RESPONSE = {
     success: boolean;
     stats?: {
@@ -27,8 +28,8 @@ export type BSOL_EMISSIONS_API_RESPONSE = {
         lend: number;
     };
 };
-export declare function fetchBSolMetrics(): Promise<any>;
-export declare function fetchBSolDriftEmissions(): Promise<any>;
+export declare function fetchBSolMetrics(): Promise<fetch.Response>;
+export declare function fetchBSolDriftEmissions(): Promise<fetch.Response>;
 export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
     marketIndex: number;
     amount: BN;

package/lib/browser/types.d.ts

@@ -696,6 +696,9 @@ export type SpotBankruptcyRecord = {
     cumulativeDepositInterestDelta: BN;
     ifPayment: BN;
 };
+export declare class LiquidationBitFlag {
+    static readonly IsolatedPosition = 1;
+}
 export type SettlePnlRecord = {
     ts: BN;
     user: PublicKey;
@@ -1191,6 +1194,8 @@ export type PerpPosition = {
     lastBaseAssetAmountPerLp: BN;
     lastQuoteAssetAmountPerLp: BN;
     perLpBase: number;
+    positionFlag: number;
+    isolatedPositionScaledBalance: BN;
 };
 export type UserStatsAccount = {
     numberOfSubAccounts: number;
@@ -1340,6 +1345,11 @@ export declare class OrderParamsBitFlag {
     static readonly ImmediateOrCancel = 1;
     static readonly UpdateHighLeverageMode = 2;
 }
+export declare class PositionFlag {
+    static readonly IsolatedPosition = 1;
+    static readonly BeingLiquidated = 2;
+    static readonly Bankruptcy = 3;
+}
 export type NecessaryOrderParams = {
     orderType: OrderType;
     marketIndex: number;
@@ -1349,6 +1359,9 @@ export type NecessaryOrderParams = {
 export type OptionalOrderParams = {
     [Property in keyof OrderParams]?: OrderParams[Property];
 } & NecessaryOrderParams;
+export type PerpOrderIsolatedExtras = {
+    isolatedPositionDepositAmount?: BN;
+};
 export type ModifyOrderParams = {
     [Property in keyof OrderParams]?: OrderParams[Property] | null;
 } & {

package/lib/browser/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstituentLpOperation = exports.ConstituentStatus = exports.OracleValidity = exports.SwapReduceOnly = exports.PlaceAndTakeOrderSuccessCondition = exports.FuelOverflowStatus = exports.ReferrerStatus = exports.DefaultOrderParams = exports.ModifyOrderPolicy = exports.OrderParamsBitFlag = exports.PostOnlyParams = exports.LiquidationType = exports.LPAction = exports.TradeSide = exports.getVariant = exports.isOneOfVariant = exports.isVariant = exports.SettlePnlMode = exports.StakeAction = exports.SpotFulfillmentConfigStatus = exports.SettlePnlExplanation = exports.DepositExplanation = exports.SpotFulfillmentStatus = exports.SpotFulfillmentType = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderBitFlag = exports.OrderStatus = exports.MarketType = exports.OrderType = exports.OracleSourceNum = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.SpotBalanceType = exports.SwapDirection = exports.TokenProgramFlag = exports.AssetTier = exports.ContractTier = exports.ContractType = exports.MarginMode = exports.UserStatus = exports.InsuranceFundOperation = exports.SpotOperation = exports.PerpOperation = exports.MarketStatus = exports.FeatureBitFlags = exports.ExchangeStatus = void 0;
+exports.ConstituentStatus = exports.OracleValidity = exports.SwapReduceOnly = exports.PlaceAndTakeOrderSuccessCondition = exports.FuelOverflowStatus = exports.ReferrerStatus = exports.DefaultOrderParams = exports.ModifyOrderPolicy = exports.PositionFlag = exports.OrderParamsBitFlag = exports.PostOnlyParams = exports.LiquidationBitFlag = exports.LiquidationType = exports.LPAction = exports.TradeSide = exports.getVariant = exports.isOneOfVariant = exports.isVariant = exports.SettlePnlMode = exports.StakeAction = exports.SpotFulfillmentConfigStatus = exports.SettlePnlExplanation = exports.DepositExplanation = exports.SpotFulfillmentStatus = exports.SpotFulfillmentType = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderBitFlag = exports.OrderStatus = exports.MarketType = exports.OrderType = exports.OracleSourceNum = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.SpotBalanceType = exports.SwapDirection = exports.TokenProgramFlag = exports.AssetTier = exports.ContractTier = exports.ContractType = exports.MarginMode = exports.UserStatus = exports.InsuranceFundOperation = exports.SpotOperation = exports.PerpOperation = exports.MarketStatus = exports.FeatureBitFlags = exports.ExchangeStatus = void 0;
+exports.ConstituentLpOperation = void 0;
 const numericConstants_1 = require("./constants/numericConstants");
 // # Utility Types / Enums / Constants
 var ExchangeStatus;
@@ -352,6 +353,10 @@ LiquidationType.SPOT_BANKRUPTCY = {
 LiquidationType.LIQUIDATE_SPOT = {
     liquidateSpot: {},
 };
+class LiquidationBitFlag {
+}
+exports.LiquidationBitFlag = LiquidationBitFlag;
+LiquidationBitFlag.IsolatedPosition = 1;
 class PostOnlyParams {
 }
 exports.PostOnlyParams = PostOnlyParams;
@@ -364,6 +369,12 @@ class OrderParamsBitFlag {
 exports.OrderParamsBitFlag = OrderParamsBitFlag;
 OrderParamsBitFlag.ImmediateOrCancel = 1;
 OrderParamsBitFlag.UpdateHighLeverageMode = 2;
+class PositionFlag {
+}
+exports.PositionFlag = PositionFlag;
+PositionFlag.IsolatedPosition = 1;
+PositionFlag.BeingLiquidated = 2;
+PositionFlag.Bankruptcy = 3;
 var ModifyOrderPolicy;
 (function (ModifyOrderPolicy) {
     ModifyOrderPolicy[ModifyOrderPolicy["MustModify"] = 1] = "MustModify";

package/lib/browser/user.d.ts

@@ -12,6 +12,8 @@ import { UserStats } from './userStats';
 import { OraclePriceData } from './oracles/types';
 import { UserConfig } from './userConfig';
 import { StrictOraclePrice } from './oracles/strictOraclePrice';
+import { MarginCalculation } from './marginCalculation';
+export type MarginType = 'Cross' | 'Isolated';
 export declare class User {
     driftClient: DriftClient;
     userAccountPublicKey: PublicKey;
@@ -60,6 +62,7 @@ export declare class User {
      */
     getTokenAmount(marketIndex: number): BN;
     getEmptyPosition(marketIndex: number): PerpPosition;
+    getIsolatePerpPositionTokenAmount(perpMarketIndex: number): BN;
     getClonedPosition(position: PerpPosition): PerpPosition;
     getOrderForUserAccount(userAccount: UserAccount, orderId: number): Order | undefined;
     /**
@@ -96,19 +99,32 @@ export declare class User {
      * calculates Free Collateral = Total collateral - margin requirement
      * @returns : Precision QUOTE_PRECISION
      */
-    getFreeCollateral(marginCategory?: MarginCategory, enterHighLeverageMode?: any): BN;
+    getFreeCollateral(marginCategory?: MarginCategory, enterHighLeverageMode?: boolean, perpMarketIndex?: number): BN;
     /**
-     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+     * @deprecated Use the overload that includes { marginType, perpMarketIndex }
      */
-    getMarginRequirement(marginCategory: MarginCategory, liquidationBuffer?: BN, strict?: boolean, includeOpenOrders?: boolean, enteringHighLeverage?: any): BN;
+    getMarginRequirement(marginCategory: MarginCategory, liquidationBuffer?: BN, strict?: boolean, includeOpenOrders?: boolean, enteringHighLeverage?: boolean): BN;
+    /**
+     * Calculates the margin requirement based on the specified parameters.
+     *
+     * @param marginCategory - The category of margin to calculate ('Initial' or 'Maintenance').
+     * @param liquidationBuffer - Optional buffer amount to consider during liquidation scenarios.
+     * @param strict - Optional flag to enforce strict margin calculations.
+     * @param includeOpenOrders - Optional flag to include open orders in the margin calculation.
+     * @param enteringHighLeverage - Optional flag indicating if the user is entering high leverage mode.
+     * @param perpMarketIndex - Optional index of the perpetual market. Required if marginType is 'Isolated'.
+     *
+     * @returns The calculated margin requirement as a BN (BigNumber).
+     */
+    getMarginRequirement(marginCategory: MarginCategory, liquidationBuffer?: BN, strict?: boolean, includeOpenOrders?: boolean, enteringHighLeverage?: boolean, perpMarketIndex?: number): BN;
     /**
      * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getInitialMarginRequirement(enterHighLeverageMode?: any): BN;
+    getInitialMarginRequirement(enterHighLeverageMode?: boolean, perpMarketIndex?: number): BN;
     /**
      * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
      */
-    getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN;
+    getMaintenanceMarginRequirement(liquidationBuffer?: BN, perpMarketIndex?: number): BN;
     getActivePerpPositionsForUserAccount(userAccount: UserAccount): PerpPosition[];
     getActivePerpPositions(): PerpPosition[];
     getActivePerpPositionsAndSlot(): DataAndSlot<PerpPosition[]>;
@@ -147,13 +163,13 @@ export declare class User {
      * calculates TotalCollateral: collateral + unrealized pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getTotalCollateral(marginCategory?: MarginCategory, strict?: boolean, includeOpenOrders?: boolean, liquidationBuffer?: BN): BN;
+    getTotalCollateral(marginCategory?: MarginCategory, strict?: boolean, includeOpenOrders?: boolean, liquidationBuffer?: BN, perpMarketIndex?: number): BN;
     getLiquidationBuffer(): BN | undefined;
     /**
      * calculates User Health by comparing total collateral and maint. margin requirement
      * @returns : number (value from [0, 100])
      */
-    getHealth(): number;
+    getHealth(perpMarketIndex?: number): number;
     calculateWeightedPerpPositionLiability(perpPosition: PerpPosition, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, enteringHighLeverage?: any): BN;
     /**
      * calculates position value of a single perp market in margin system
@@ -185,14 +201,14 @@ export declare class User {
      * calculates current user leverage which is (total liability size) / (net asset value)
      * @returns : Precision TEN_THOUSAND
      */
-    getLeverage(includeOpenOrders?: boolean): BN;
+    getLeverage(includeOpenOrders?: boolean, perpMarketIndex?: number): BN;
     calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }: {
         perpLiabilityValue: BN;
         perpPnl: BN;
         spotAssetValue: BN;
         spotLiabilityValue: BN;
     }): BN;
-    getLeverageComponents(includeOpenOrders?: boolean, marginCategory?: MarginCategory): {
+    getLeverageComponents(includeOpenOrders?: boolean, marginCategory?: MarginCategory, perpMarketIndex?: number): {
         perpLiabilityValue: BN;
         perpPnl: BN;
         spotAssetValue: BN;
@@ -234,8 +250,28 @@ export declare class User {
         canBeLiquidated: boolean;
         marginRequirement: BN;
         totalCollateral: BN;
+        liquidationStatuses: Map<'cross' | number, {
+            canBeLiquidated: boolean;
+            marginRequirement: BN;
+            totalCollateral: BN;
+        }>;
     };
-    isBeingLiquidated(): boolean;
+    /**
+     * 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?: MarginCalculation): Map<'cross' | number, {
+        canBeLiquidated: boolean;
+        marginRequirement: BN;
+        totalCollateral: BN;
+    }>;
+    isBeingLiquidated(marginCalc?: MarginCalculation): boolean;
+    /** Returns true if cross margin is currently below maintenance requirement (no buffer). */
+    isCrossMarginBeingLiquidated(marginCalc?: MarginCalculation): boolean;
+    /** Returns true if any isolated perp position is currently below its maintenance requirement (no buffer). */
+    isIsolatedMarginBeingLiquidated(marginCalc?: MarginCalculation): boolean;
     hasStatus(status: UserStatus): boolean;
     isBankrupt(): boolean;
     isHighLeverageMode(marginCategory: MarginCategory): boolean;
@@ -260,7 +296,7 @@ export declare 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: number, positionBaseSizeChange?: BN, estimatedEntryPrice?: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean, offsetCollateral?: BN, enteringHighLeverage?: any): BN;
+    liquidationPrice(marketIndex: number, positionBaseSizeChange?: BN, estimatedEntryPrice?: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean, offsetCollateral?: BN, enteringHighLeverage?: boolean, marginType?: MarginType): BN;
     calculateEntriesEffectOnFreeCollateral(market: PerpMarketAccount, oraclePrice: BN, perpPosition: PerpPosition, positionBaseSizeChange: BN, estimatedEntryPrice: BN, includeOpenOrders: boolean, enteringHighLeverage?: any, marginCategory?: MarginCategory): BN;
     calculateFreeCollateralDeltaForPerp(market: PerpMarketAccount, perpPosition: PerpPosition, positionBaseSizeChange: BN, oraclePrice: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean, enteringHighLeverage?: any): BN | undefined;
     calculateFreeCollateralDeltaForSpot(market: SpotMarketAccount, signedTokenAmount: BN, marginCategory?: MarginCategory): BN;
@@ -395,4 +431,16 @@ export declare class User {
         activePerpPositions: number[];
         activeSpotPositions: number[];
     };
+    /**
+     * Compute a consolidated margin snapshot once, without caching.
+     * Consumers can use this to avoid duplicating work across separate calls.
+     */
+    getMarginCalculation(marginCategory?: MarginCategory, opts?: {
+        strict?: boolean;
+        includeOpenOrders?: boolean;
+        enteringHighLeverage?: boolean;
+        liquidationBuffer?: BN;
+        marginRatioOverride?: number;
+    }): MarginCalculation;
+    private isPerpPositionIsolated;
 }