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

package/VERSION

@@ -1 +1 @@
-2.149.0-beta.0
+2.149.0-beta.1

package/lib/browser/marginCalculation.d.ts

@@ -0,0 +1,79 @@
+/// <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;
+}

package/lib/browser/marginCalculation.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarginCalculation = exports.IsolatedMarginCalculation = exports.MarginContext = exports.MarketIdentifier = void 0;
+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 &&
+            (0, types_1.isVariant)(this.marketType, (0, types_1.getVariant)(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.isolatedMarginBuffers = new Map();
+    }
+    static standard(marginType) {
+        return new MarginContext(marginType);
+    }
+    static liquidation(crossMarginBuffer, isolatedMarginBuffers) {
+        const ctx = new MarginContext('Maintenance');
+        ctx.mode = { type: 'Liquidation' };
+        ctx.crossMarginBuffer = crossMarginBuffer;
+        ctx.isolatedMarginBuffers = isolatedMarginBuffers;
+        return ctx;
+    }
+    strictMode(strict) {
+        this.strict = strict;
+        return this;
+    }
+    ignoreInvalidDeposits(ignore) {
+        this.ignoreInvalidDepositOracles = ignore;
+        return this;
+    }
+    setCrossMarginBuffer(crossMarginBuffer) {
+        this.crossMarginBuffer = crossMarginBuffer;
+        return this;
+    }
+    setIsolatedMarginBuffers(isolatedMarginBuffers) {
+        this.isolatedMarginBuffers = isolatedMarginBuffers;
+        return this;
+    }
+    setIsolatedMarginBuffer(marketIndex, isolatedMarginBuffer) {
+        this.isolatedMarginBuffers.set(marketIndex, isolatedMarginBuffer);
+        return this;
+    }
+}
+exports.MarginContext = MarginContext;
+class IsolatedMarginCalculation {
+    constructor() {
+        this.marginRequirement = numericConstants_1.ZERO;
+        this.totalCollateral = numericConstants_1.ZERO;
+        this.totalCollateralBuffer = numericConstants_1.ZERO;
+        this.marginRequirementPlusBuffer = numericConstants_1.ZERO;
+    }
+    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() ? numericConstants_1.ZERO : shortage;
+    }
+}
+exports.IsolatedMarginCalculation = IsolatedMarginCalculation;
+class MarginCalculation {
+    constructor(context) {
+        this.context = context;
+        this.totalCollateral = numericConstants_1.ZERO;
+        this.totalCollateralBuffer = numericConstants_1.ZERO;
+        this.marginRequirement = numericConstants_1.ZERO;
+        this.marginRequirementPlusBuffer = numericConstants_1.ZERO;
+        this.isolatedMarginCalculations = new Map();
+        this.allDepositOraclesValid = true;
+        this.allLiabilityOraclesValid = true;
+        this.withPerpIsolatedLiability = false;
+        this.withSpotIsolatedLiability = false;
+        this.totalPerpLiabilityValue = numericConstants_1.ZERO;
+        this.trackedMarketMarginRequirement = numericConstants_1.ZERO;
+        this.fuelDeposits = 0;
+        this.fuelBorrows = 0;
+        this.fuelPositions = 0;
+    }
+    addCrossMarginTotalCollateral(delta) {
+        const crossMarginBuffer = this.context.crossMarginBuffer;
+        this.totalCollateral = this.totalCollateral.add(delta);
+        if (crossMarginBuffer.gt(numericConstants_1.ZERO) && delta.isNeg()) {
+            this.totalCollateralBuffer = this.totalCollateralBuffer.add(delta.mul(crossMarginBuffer).div(numericConstants_1.MARGIN_PRECISION));
+        }
+    }
+    addCrossMarginRequirement(marginRequirement, liabilityValue) {
+        const crossMarginBuffer = this.context.crossMarginBuffer;
+        this.marginRequirement = this.marginRequirement.add(marginRequirement);
+        if (crossMarginBuffer.gt(numericConstants_1.ZERO)) {
+            this.marginRequirementPlusBuffer = this.marginRequirementPlusBuffer.add(marginRequirement.add(liabilityValue.mul(crossMarginBuffer).div(numericConstants_1.MARGIN_PRECISION)));
+        }
+    }
+    addIsolatedMarginCalculation(marketIndex, depositValue, pnl, liabilityValue, marginRequirement) {
+        var _a;
+        const totalCollateral = depositValue.add(pnl);
+        const isolatedMarginBuffer = (_a = this.context.isolatedMarginBuffers.get(marketIndex)) !== null && _a !== void 0 ? _a : numericConstants_1.ZERO;
+        const totalCollateralBuffer = isolatedMarginBuffer.gt(numericConstants_1.ZERO) && pnl.isNeg()
+            ? pnl.mul(isolatedMarginBuffer).div(numericConstants_1.MARGIN_PRECISION)
+            : numericConstants_1.ZERO;
+        const marginRequirementPlusBuffer = isolatedMarginBuffer.gt(numericConstants_1.ZERO)
+            ? marginRequirement.add(liabilityValue.mul(isolatedMarginBuffer).div(numericConstants_1.MARGIN_PRECISION))
+            : marginRequirement;
+        const iso = new IsolatedMarginCalculation();
+        iso.marginRequirement = marginRequirement;
+        iso.totalCollateral = totalCollateral;
+        iso.totalCollateralBuffer = totalCollateralBuffer;
+        iso.marginRequirementPlusBuffer = marginRequirementPlusBuffer;
+        this.isolatedMarginCalculations.set(marketIndex, iso);
+    }
+    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;
+    }
+    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() ? numericConstants_1.ZERO : 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() ? numericConstants_1.ZERO : 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,10 +89,16 @@ 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) {
+    const isPredictionMarket = (0, types_1.isVariant)(perpMarket.contractType, 'prediction');
+    if (!includeOpenOrders) {
+        return {
+            worstCaseBaseAssetAmount: perpPosition.baseAssetAmount,
+            worstCaseLiabilityValue: calculatePerpLiabilityValue(perpPosition.baseAssetAmount, oraclePrice, isPredictionMarket),
+        };
+    }
     const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
     const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
-    const isPredictionMarket = (0, types_1.isVariant)(perpMarket.contractType, 'prediction');
     const allBidsLiabilityValue = calculatePerpLiabilityValue(allBids, oraclePrice, isPredictionMarket);
     const allAsksLiabilityValue = calculatePerpLiabilityValue(allAsks, oraclePrice, isPredictionMarket);
     if (allAsksLiabilityValue.gte(allBidsLiabilityValue)) {

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/types.d.ts

@@ -1195,6 +1195,11 @@ export type PerpPosition = {
     isolatedPositionScaledBalance: BN;
     positionFlag: number;
 };
+export declare class PositionFlag {
+    static readonly IsolatedPosition = 1;
+    static readonly BeingLiquidated = 2;
+    static readonly Bankruptcy = 4;
+}
 export type UserStatsAccount = {
     numberOfSubAccounts: number;
     numberOfSubAccountsCreated: number;
@@ -1860,4 +1865,9 @@ export type CacheInfo = {
 export type AmmCache = {
     cache: CacheInfo[];
 };
+export type AccountLiquidatableStatus = {
+    canBeLiquidated: boolean;
+    marginRequirement: BN;
+    totalCollateral: BN;
+};
 export {};

package/lib/browser/types.js

@@ -1,6 +1,6 @@
 "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.ConstituentLpOperation = exports.ConstituentStatus = exports.OracleValidity = exports.SwapReduceOnly = exports.PlaceAndTakeOrderSuccessCondition = exports.FuelOverflowStatus = exports.ReferrerStatus = exports.DefaultOrderParams = exports.ModifyOrderPolicy = exports.OrderParamsBitFlag = exports.PostOnlyParams = exports.PositionFlag = 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;
 const numericConstants_1 = require("./constants/numericConstants");
 // # Utility Types / Enums / Constants
 var ExchangeStatus;
@@ -353,6 +353,12 @@ LiquidationType.SPOT_BANKRUPTCY = {
 LiquidationType.LIQUIDATE_SPOT = {
     liquidateSpot: {},
 };
+class PositionFlag {
+}
+exports.PositionFlag = PositionFlag;
+PositionFlag.IsolatedPosition = 1;
+PositionFlag.BeingLiquidated = 2;
+PositionFlag.Bankruptcy = 4;
 class PostOnlyParams {
 }
 exports.PostOnlyParams = PostOnlyParams;

package/lib/browser/user.d.ts

@@ -4,7 +4,7 @@ import { PublicKey } from '@solana/web3.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { DriftClient } from './driftClient';
-import { HealthComponent, HealthComponents, MarginCategory, Order, PerpMarketAccount, PerpPosition, SpotPosition, UserAccount, UserStatus } from './types';
+import { HealthComponent, HealthComponents, MarginCategory, Order, PerpMarketAccount, PerpPosition, SpotPosition, UserAccount, UserStatus, AccountLiquidatableStatus } from './types';
 import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './accounts/types';
 import { BN } from '@coral-xyz/anchor';
 import { MarketType, PositionDirection, SpotMarketAccount } from './types';
@@ -12,6 +12,8 @@ import { UserStats } from './userStats';
 import { OraclePriceData } from './oracles/types';
 import { UserConfig } from './userConfig';
 import { StrictOraclePrice } from './oracles/strictOraclePrice';
+import { IsolatedMarginCalculation, 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;
-    getLiquidationBuffer(): BN | undefined;
+    getTotalCollateral(marginCategory?: MarginCategory, strict?: boolean, includeOpenOrders?: boolean, liquidationBuffer?: BN, perpMarketIndex?: number): BN;
+    getLiquidationBuffer(): Map<number | 'cross', BN>;
     /**
      * 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;
@@ -230,12 +246,25 @@ export declare class User {
      * @returns : Precision TEN_THOUSAND
      */
     getMarginRatio(): BN;
-    canBeLiquidated(): {
-        canBeLiquidated: boolean;
-        marginRequirement: BN;
-        totalCollateral: BN;
+    canBeLiquidated(): AccountLiquidatableStatus & {
+        isolatedPositions: Map<number, AccountLiquidatableStatus>;
     };
+    /**
+     * 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, AccountLiquidatableStatus>;
     isBeingLiquidated(): boolean;
+    isCrossMarginBeingLiquidated(): boolean;
+    /** Returns true if cross margin is currently below maintenance requirement (no buffer). */
+    canCrossMarginBeLiquidated(marginCalc?: MarginCalculation): boolean;
+    hasIsolatedPositionBeingLiquidated(): boolean;
+    isIsolatedPositionBeingLiquidated(perpMarketIndex: number): boolean;
+    /** Returns true if any isolated perp position is currently below its maintenance requirement (no buffer). */
+    getLiquidatableIsolatedPositions(marginCalc?: MarginCalculation): number[];
+    canIsolatedPositionMarginBeLiquidated(isolatedMarginCalculation: IsolatedMarginCalculation): boolean;
     hasStatus(status: UserStatus): boolean;
     isBankrupt(): boolean;
     isHighLeverageMode(marginCategory: MarginCategory): boolean;
@@ -260,7 +289,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 +424,15 @@ 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;
+        liquidationBufferMap?: Map<number | 'cross', BN>;
+    }): MarginCalculation;
+    private isPerpPositionIsolated;
 }