@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.40

package/lib/user.js

@@ -0,0 +1,949 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const types_1 = require("./types");
+const position_1 = require("./math/position");
+const numericConstants_1 = require("./constants/numericConstants");
+const _1 = require(".");
+const spotBalance_1 = require("./math/spotBalance");
+const amm_1 = require("./math/amm");
+const margin_1 = require("./math/margin");
+const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
+const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
+const spotPosition_1 = require("./math/spotPosition");
+class User {
+    constructor(config) {
+        var _a;
+        this._isSubscribed = false;
+        this.driftClient = config.driftClient;
+        this.userAccountPublicKey = config.userAccountPublicKey;
+        if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
+            this.accountSubscriber = new pollingUserAccountSubscriber_1.PollingUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey, config.accountSubscription.accountLoader);
+        }
+        else {
+            this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey);
+        }
+        this.eventEmitter = this.accountSubscriber.eventEmitter;
+    }
+    get isSubscribed() {
+        return this._isSubscribed && this.accountSubscriber.isSubscribed;
+    }
+    set isSubscribed(val) {
+        this._isSubscribed = val;
+    }
+    /**
+     * Subscribe to User state accounts
+     * @returns SusbcriptionSuccess result
+     */
+    async subscribe() {
+        this.isSubscribed = await this.accountSubscriber.subscribe();
+        return this.isSubscribed;
+    }
+    /**
+     *	Forces the accountSubscriber to fetch account updates from rpc
+     */
+    async fetchAccounts() {
+        await this.accountSubscriber.fetch();
+    }
+    async unsubscribe() {
+        await this.accountSubscriber.unsubscribe();
+        this.isSubscribed = false;
+    }
+    getUserAccount() {
+        return this.accountSubscriber.getUserAccountAndSlot().data;
+    }
+    getUserAccountAndSlot() {
+        return this.accountSubscriber.getUserAccountAndSlot();
+    }
+    /**
+     * Gets the user's current position for a given perp market. If the user has no position returns undefined
+     * @param marketIndex
+     * @returns userPerpPosition
+     */
+    getPerpPosition(marketIndex) {
+        return this.getUserAccount().perpPositions.find((position) => position.marketIndex === marketIndex);
+    }
+    /**
+     * Gets the user's current position for a given spot market. If the user has no position returns undefined
+     * @param marketIndex
+     * @returns userSpotPosition
+     */
+    getSpotPosition(marketIndex) {
+        return this.getUserAccount().spotPositions.find((position) => position.marketIndex === marketIndex);
+    }
+    getEmptyPosition(marketIndex) {
+        return {
+            baseAssetAmount: numericConstants_1.ZERO,
+            remainderBaseAssetAmount: 0,
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
+            marketIndex,
+            quoteAssetAmount: numericConstants_1.ZERO,
+            quoteEntryAmount: numericConstants_1.ZERO,
+            quoteBreakEvenAmount: numericConstants_1.ZERO,
+            openOrders: 0,
+            openBids: numericConstants_1.ZERO,
+            openAsks: numericConstants_1.ZERO,
+            settledPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
+        };
+    }
+    getClonedPosition(position) {
+        const clonedPosition = Object.assign({}, position);
+        return clonedPosition;
+    }
+    /**
+     * @param orderId
+     * @returns Order
+     */
+    getOrder(orderId) {
+        return this.getUserAccount().orders.find((order) => order.orderId === orderId);
+    }
+    /**
+     * @param userOrderId
+     * @returns Order
+     */
+    getOrderByUserOrderId(userOrderId) {
+        return this.getUserAccount().orders.find((order) => order.userOrderId === userOrderId);
+    }
+    getUserAccountPublicKey() {
+        return this.userAccountPublicKey;
+    }
+    async exists() {
+        const userAccountRPCResponse = await this.driftClient.connection.getParsedAccountInfo(this.userAccountPublicKey);
+        return userAccountRPCResponse.value !== null;
+    }
+    /**
+     * calculates the total open bids/asks in a perp market (including lps)
+     * @returns : open bids
+     * @returns : open asks
+     */
+    getPerpBidAsks(marketIndex) {
+        const position = this.getPerpPosition(marketIndex);
+        const [lpOpenBids, lpOpenAsks] = this.getLPBidAsks(marketIndex);
+        const totalOpenBids = lpOpenBids.add(position.openBids);
+        const totalOpenAsks = lpOpenAsks.add(position.openAsks);
+        return [totalOpenBids, totalOpenAsks];
+    }
+    /**
+     * calculates the open bids and asks for an lp
+     * @returns : lp open bids
+     * @returns : lp open asks
+     */
+    getLPBidAsks(marketIndex) {
+        const position = this.getPerpPosition(marketIndex);
+        if (position === undefined || position.lpShares.eq(numericConstants_1.ZERO)) {
+            return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const market = this.driftClient.getPerpMarketAccount(marketIndex);
+        const [marketOpenBids, marketOpenAsks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve);
+        const lpOpenBids = marketOpenBids
+            .mul(position.lpShares)
+            .div(market.amm.sqrtK);
+        const lpOpenAsks = marketOpenAsks
+            .mul(position.lpShares)
+            .div(market.amm.sqrtK);
+        return [lpOpenBids, lpOpenAsks];
+    }
+    /**
+     * calculates the market position if the lp position was settled
+     * @returns : the settled userPosition
+     * @returns : the dust base asset amount (ie, < stepsize)
+     * @returns : pnl from settle
+     */
+    getSettledLPPosition(marketIndex) {
+        const _position = this.getPerpPosition(marketIndex);
+        const position = this.getClonedPosition(_position);
+        if (position.lpShares.eq(numericConstants_1.ZERO)) {
+            return [position, numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const market = this.driftClient.getPerpMarketAccount(position.marketIndex);
+        const nShares = position.lpShares;
+        const deltaBaa = market.amm.baseAssetAmountPerLp
+            .sub(position.lastNetBaseAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        const deltaQaa = market.amm.quoteAssetAmountPerLp
+            .sub(position.lastNetQuoteAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        function sign(v) {
+            const sign = { true: new _1.BN(1), false: new _1.BN(-1) }[v.gte(numericConstants_1.ZERO).toString()];
+            return sign;
+        }
+        function standardize(amount, stepsize) {
+            const remainder = amount.abs().mod(stepsize).mul(sign(amount));
+            const standardizedAmount = amount.sub(remainder);
+            return [standardizedAmount, remainder];
+        }
+        const [standardizedBaa, remainderBaa] = standardize(deltaBaa, market.amm.orderStepSize);
+        position.remainderBaseAssetAmount += remainderBaa.toNumber();
+        if (Math.abs(position.remainderBaseAssetAmount) >
+            market.amm.orderStepSize.toNumber()) {
+            const [newStandardizedBaa, newRemainderBaa] = standardize(new _1.BN(position.remainderBaseAssetAmount), market.amm.orderStepSize);
+            position.baseAssetAmount =
+                position.baseAssetAmount.add(newStandardizedBaa);
+            position.remainderBaseAssetAmount = newRemainderBaa.toNumber();
+        }
+        let updateType;
+        if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+            updateType = 'open';
+        }
+        else if (sign(position.baseAssetAmount).eq(sign(deltaBaa))) {
+            updateType = 'increase';
+        }
+        else if (position.baseAssetAmount.abs().gt(deltaBaa.abs())) {
+            updateType = 'reduce';
+        }
+        else if (position.baseAssetAmount.abs().eq(deltaBaa.abs())) {
+            updateType = 'close';
+        }
+        else {
+            updateType = 'flip';
+        }
+        let newQuoteEntry;
+        let pnl;
+        if (updateType == 'open' || updateType == 'increase') {
+            newQuoteEntry = position.quoteEntryAmount.add(deltaQaa);
+            pnl = 0;
+        }
+        else if (updateType == 'reduce' || updateType == 'close') {
+            newQuoteEntry = position.quoteEntryAmount.sub(position.quoteEntryAmount
+                .mul(deltaBaa.abs())
+                .div(position.baseAssetAmount.abs()));
+            pnl = position.quoteEntryAmount.sub(newQuoteEntry).add(deltaQaa);
+        }
+        else {
+            newQuoteEntry = deltaQaa.sub(deltaQaa.mul(position.baseAssetAmount.abs()).div(deltaBaa.abs()));
+            pnl = position.quoteEntryAmount.add(deltaQaa.sub(newQuoteEntry));
+        }
+        position.quoteEntryAmount = newQuoteEntry;
+        position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
+        position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
+        if (position.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+            position.lastCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+        }
+        else if (position.baseAssetAmount.lt(numericConstants_1.ZERO)) {
+            position.lastCumulativeFundingRate =
+                market.amm.cumulativeFundingRateShort;
+        }
+        else {
+            position.lastCumulativeFundingRate = numericConstants_1.ZERO;
+        }
+        return [position, remainderBaa, pnl];
+    }
+    /**
+     * calculates Buying Power = FC * MAX_LEVERAGE
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getBuyingPower(marketIndex) {
+        return this.getFreeCollateral()
+            .mul(this.getMaxLeverage(marketIndex, 'Initial'))
+            .div(numericConstants_1.TEN_THOUSAND);
+    }
+    /**
+     * calculates Free Collateral = Total collateral - initial margin requirement
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getFreeCollateral() {
+        const totalCollateral = this.getTotalCollateral();
+        const initialMarginRequirement = this.getInitialMarginRequirement();
+        const freeCollateral = totalCollateral.sub(initialMarginRequirement);
+        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) {
+        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, liquidationBuffer, true));
+    }
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getInitialMarginRequirement() {
+        return this.getMarginRequirement('Initial');
+    }
+    /**
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getMaintenanceMarginRequirement(liquidationBuffer) {
+        return this.getMarginRequirement('Maintenance', liquidationBuffer);
+    }
+    /**
+     * calculates unrealized position price pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getUnrealizedPNL(withFunding, marketIndex, withWeightMarginCategory) {
+        const quoteSpotMarket = this.driftClient.getQuoteSpotMarketAccount();
+        return this.getUserAccount()
+            .perpPositions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
+            .reduce((unrealizedPnl, perpPosition) => {
+            const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            const oraclePriceData = this.getOracleDataForPerpMarket(market.marketIndex);
+            let positionUnrealizedPnl = (0, _1.calculatePositionPNL)(market, perpPosition, withFunding, oraclePriceData);
+            if (withWeightMarginCategory !== undefined) {
+                if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                    positionUnrealizedPnl = positionUnrealizedPnl
+                        .mul((0, _1.calculateUnrealizedAssetWeight)(market, quoteSpotMarket, positionUnrealizedPnl, withWeightMarginCategory, oraclePriceData))
+                        .div(new _1.BN(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION));
+                }
+            }
+            return unrealizedPnl.add(positionUnrealizedPnl);
+        }, numericConstants_1.ZERO);
+    }
+    /**
+     * calculates unrealized funding payment pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getUnrealizedFundingPNL(marketIndex) {
+        return this.getUserAccount()
+            .perpPositions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
+            .reduce((pnl, perpPosition) => {
+            const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            return pnl.add((0, _1.calculatePositionFundingPNL)(market, perpPosition));
+        }, numericConstants_1.ZERO);
+    }
+    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders) {
+        return this.getUserAccount().spotPositions.reduce((totalLiabilityValue, spotPosition) => {
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition) ||
+                (marketIndex !== undefined &&
+                    spotPosition.marketIndex !== marketIndex)) {
+                return totalLiabilityValue;
+            }
+            const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'borrow')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
+                    let weight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
+                    if (marginCategory === 'Initial') {
+                        weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
+                    }
+                    const weightedTokenValue = tokenAmount
+                        .mul(weight)
+                        .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+                    return totalLiabilityValue.add(weightedTokenValue);
+                }
+                else {
+                    return totalLiabilityValue;
+                }
+            }
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            if (!includeOpenOrders) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'borrow')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
+                    const liabilityValue = this.getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer);
+                    return totalLiabilityValue.add(liabilityValue);
+                }
+                else {
+                    return totalLiabilityValue;
+                }
+            }
+            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, this.getOracleDataForSpotMarket(spotPosition.marketIndex));
+            let newTotalLiabilityValue = totalLiabilityValue;
+            if (worstCaseTokenAmount.lt(numericConstants_1.ZERO)) {
+                const baseLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount.abs(), oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer);
+                newTotalLiabilityValue =
+                    newTotalLiabilityValue.add(baseLiabilityValue);
+            }
+            if (worstCaseQuoteTokenAmount.lt(numericConstants_1.ZERO)) {
+                let weight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
+                if (marginCategory === 'Initial') {
+                    weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
+                }
+                const weightedTokenValue = worstCaseQuoteTokenAmount
+                    .abs()
+                    .mul(weight)
+                    .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+                newTotalLiabilityValue =
+                    newTotalLiabilityValue.add(weightedTokenValue);
+            }
+            return newTotalLiabilityValue;
+        }, numericConstants_1.ZERO);
+    }
+    getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer) {
+        let liabilityValue = (0, _1.getTokenValue)(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+        if (marginCategory !== undefined) {
+            let weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount, spotMarketAccount, marginCategory);
+            if (marginCategory === 'Initial') {
+                weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
+            }
+            if (liquidationBuffer !== undefined) {
+                weight = weight.add(liquidationBuffer);
+            }
+            liabilityValue = liabilityValue
+                .mul(weight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+        }
+        return liabilityValue;
+    }
+    getSpotMarketAssetValue(marketIndex, marginCategory, includeOpenOrders) {
+        return this.getUserAccount().spotPositions.reduce((totalAssetValue, spotPosition) => {
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition) ||
+                (marketIndex !== undefined &&
+                    spotPosition.marketIndex !== marketIndex)) {
+                return totalAssetValue;
+            }
+            // Todo this needs to account for whether it's based on initial or maintenance requirements
+            const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'deposit')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
+                    return totalAssetValue.add(tokenAmount);
+                }
+                else {
+                    return totalAssetValue;
+                }
+            }
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            if (!includeOpenOrders) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'deposit')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
+                    const assetValue = this.getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory);
+                    return totalAssetValue.add(assetValue);
+                }
+                else {
+                    return totalAssetValue;
+                }
+            }
+            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, this.getOracleDataForSpotMarket(spotPosition.marketIndex));
+            let newTotalAssetValue = totalAssetValue;
+            if (worstCaseTokenAmount.gt(numericConstants_1.ZERO)) {
+                const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory);
+                newTotalAssetValue = newTotalAssetValue.add(baseAssetValue);
+            }
+            if (worstCaseQuoteTokenAmount.gt(numericConstants_1.ZERO)) {
+                newTotalAssetValue = newTotalAssetValue.add(worstCaseQuoteTokenAmount);
+            }
+            return newTotalAssetValue;
+        }, numericConstants_1.ZERO);
+    }
+    getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory) {
+        let assetValue = (0, _1.getTokenValue)(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+        if (marginCategory !== undefined) {
+            const weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, spotMarketAccount, marginCategory);
+            assetValue = assetValue.mul(weight).div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+        }
+        return assetValue;
+    }
+    getNetSpotMarketValue(withWeightMarginCategory) {
+        return this.getSpotMarketAssetValue(undefined, withWeightMarginCategory).sub(this.getSpotMarketLiabilityValue(undefined, withWeightMarginCategory));
+    }
+    /**
+     * calculates TotalCollateral: collateral + unrealized pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getTotalCollateral(marginCategory = 'Initial') {
+        return this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+    }
+    /**
+     * calculates sum of position value across all positions in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders) {
+        return this.getUserAccount().perpPositions.reduce((totalPerpValue, perpPosition) => {
+            const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                // is an lp
+                // clone so we dont mutate the position
+                perpPosition = this.getClonedPosition(perpPosition);
+                // settle position
+                const [settledPosition, dustBaa, _] = this.getSettledLPPosition(market.marketIndex);
+                perpPosition.baseAssetAmount =
+                    settledPosition.baseAssetAmount.add(dustBaa);
+                perpPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+                const [totalOpenBids, totalOpenAsks] = this.getPerpBidAsks(market.marketIndex);
+                perpPosition.openAsks = totalOpenAsks;
+                perpPosition.openBids = totalOpenBids;
+            }
+            let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
+            if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                valuationPrice = market.expiryPrice;
+            }
+            const baseAssetAmount = includeOpenOrders
+                ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
+                : perpPosition.baseAssetAmount;
+            let baseAssetValue = baseAssetAmount
+                .abs()
+                .mul(valuationPrice)
+                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
+            if (marginCategory) {
+                let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
+                if (marginCategory === 'Initial') {
+                    marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
+                }
+                if (liquidationBuffer !== undefined) {
+                    marginRatio = marginRatio.add(liquidationBuffer);
+                }
+                if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                    marginRatio = numericConstants_1.ZERO;
+                }
+                baseAssetValue = baseAssetValue
+                    .mul(marginRatio)
+                    .div(numericConstants_1.MARGIN_PRECISION);
+            }
+            return totalPerpValue.add(baseAssetValue);
+        }, numericConstants_1.ZERO);
+    }
+    /**
+     * calculates position value in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getPerpPositionValue(marketIndex, oraclePriceData) {
+        const userPosition = this.getPerpPosition(marketIndex) || this.getEmptyPosition(marketIndex);
+        const market = this.driftClient.getPerpMarketAccount(userPosition.marketIndex);
+        return (0, margin_1.calculateBaseAssetValueWithOracle)(market, userPosition, oraclePriceData);
+    }
+    getPositionSide(currentPosition) {
+        if (currentPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+            return _1.PositionDirection.LONG;
+        }
+        else if (currentPosition.baseAssetAmount.lt(numericConstants_1.ZERO)) {
+            return _1.PositionDirection.SHORT;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * calculates average exit price (optionally for closing up to 100% of position)
+     * @returns : Precision PRICE_PRECISION
+     */
+    getPositionEstimatedExitPriceAndPnl(position, amountToClose, useAMMClose = false) {
+        const market = this.driftClient.getPerpMarketAccount(position.marketIndex);
+        const entryPrice = (0, position_1.calculateEntryPrice)(position);
+        const oraclePriceData = this.getOracleDataForPerpMarket(position.marketIndex);
+        if (amountToClose) {
+            if (amountToClose.eq(numericConstants_1.ZERO)) {
+                return [(0, _1.calculateReservePrice)(market, oraclePriceData), numericConstants_1.ZERO];
+            }
+            position = {
+                baseAssetAmount: amountToClose,
+                lastCumulativeFundingRate: position.lastCumulativeFundingRate,
+                marketIndex: position.marketIndex,
+                quoteAssetAmount: position.quoteAssetAmount,
+            };
+        }
+        let baseAssetValue;
+        if (useAMMClose) {
+            baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
+        }
+        else {
+            baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, oraclePriceData);
+        }
+        if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+            return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const exitPrice = baseAssetValue
+            .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+            .mul(numericConstants_1.PRICE_PRECISION)
+            .div(position.baseAssetAmount.abs());
+        const pnlPerBase = exitPrice.sub(entryPrice);
+        const pnl = pnlPerBase
+            .mul(position.baseAssetAmount)
+            .div(numericConstants_1.PRICE_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+        return [exitPrice, pnl];
+    }
+    /**
+     * calculates current user leverage across all positions
+     * @returns : Precision TEN_THOUSAND
+     */
+    getLeverage() {
+        const totalLiabilityValue = this.getTotalLiabilityValue();
+        const totalAssetValue = this.getTotalAssetValue();
+        if (totalAssetValue.eq(numericConstants_1.ZERO) && totalLiabilityValue.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(totalAssetValue);
+    }
+    getTotalLiabilityValue() {
+        return this.getTotalPerpPositionValue(undefined, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true));
+    }
+    getTotalAssetValue() {
+        return this.getSpotMarketAssetValue(undefined, undefined, true).add(this.getUnrealizedPNL(true, undefined, undefined));
+    }
+    /**
+     * calculates max allowable leverage exceeding hitting requirement category
+     * @params category {Initial, Maintenance}
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMaxLeverage(marketIndex, category = 'Initial') {
+        const market = this.driftClient.getPerpMarketAccount(marketIndex);
+        const totalAssetValue = this.getTotalAssetValue();
+        if (totalAssetValue.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        const totalLiabilityValue = this.getTotalLiabilityValue();
+        const marginRatio = (0, _1.calculateMarketMarginRatio)(market, 
+        // worstCaseBaseAssetAmount.abs(),
+        numericConstants_1.ZERO, // todo
+        category);
+        const freeCollateral = this.getFreeCollateral();
+        // how much more liabilities can be opened w remaining free collateral
+        const additionalLiabilities = freeCollateral
+            .mul(numericConstants_1.MARGIN_PRECISION)
+            .div(new _1.BN(marginRatio));
+        return totalLiabilityValue
+            .add(additionalLiabilities)
+            .mul(numericConstants_1.TEN_THOUSAND)
+            .div(totalAssetValue);
+    }
+    /**
+     * calculates margin ratio: total collateral / |total position value|
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMarginRatio() {
+        const totalLiabilityValue = this.getTotalLiabilityValue();
+        if (totalLiabilityValue.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.BN_MAX;
+        }
+        const totalAssetValue = this.getTotalAssetValue();
+        return totalAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
+    }
+    canBeLiquidated() {
+        const totalCollateral = this.getTotalCollateral();
+        // if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
+        let liquidationBuffer = undefined;
+        if (this.getUserAccount().isBeingLiquidated) {
+            liquidationBuffer = new _1.BN(this.driftClient.getStateAccount().liquidationMarginBufferRatio);
+        }
+        const maintenanceRequirement = this.getMaintenanceMarginRequirement(liquidationBuffer);
+        return totalCollateral.lt(maintenanceRequirement);
+    }
+    /**
+     * Checks if any user position cumulative funding differs from respective market cumulative funding
+     * @returns
+     */
+    needsToSettleFundingPayment() {
+        for (const userPosition of this.getUserAccount().perpPositions) {
+            if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+                continue;
+            }
+            const market = this.driftClient.getPerpMarketAccount(userPosition.marketIndex);
+            if (market.amm.cumulativeFundingRateLong.eq(userPosition.lastCumulativeFundingRate) ||
+                market.amm.cumulativeFundingRateShort.eq(userPosition.lastCumulativeFundingRate)) {
+                continue;
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
+     * @param PerpPosition
+     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
+     * @param partial
+     * @returns Precision : PRICE_PRECISION
+     */
+    liquidationPrice(perpPosition, positionBaseSizeChange = numericConstants_1.ZERO) {
+        // solves formula for example canBeLiquidated below
+        /* example: assume BTC price is $40k (examine 10% up/down)
+
+        if 10k deposit and levered 10x short BTC => BTC up $400 means:
+        1. higher base_asset_value (+$4k)
+        2. lower collateral (-$4k)
+        3. (10k - 4k)/(100k + 4k) => 6k/104k => .0576
+
+        for 10x long, BTC down $400:
+        3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
+        const totalCollateral = this.getTotalCollateral();
+        // calculate the total position value ignoring any value from the target market of the trade
+        const totalPositionValueExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(perpPosition.marketIndex);
+        const currentPerpPosition = this.getPerpPosition(perpPosition.marketIndex) ||
+            this.getEmptyPosition(perpPosition.marketIndex);
+        const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
+        const proposedBaseAssetAmount = currentPerpPositionBaseSize.add(positionBaseSizeChange);
+        // calculate position for current market after trade
+        const proposedPerpPosition = {
+            marketIndex: perpPosition.marketIndex,
+            baseAssetAmount: proposedBaseAssetAmount,
+            remainderBaseAssetAmount: 0,
+            quoteAssetAmount: new _1.BN(0),
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
+            quoteBreakEvenAmount: new _1.BN(0),
+            quoteEntryAmount: new _1.BN(0),
+            openOrders: 0,
+            openBids: new _1.BN(0),
+            openAsks: new _1.BN(0),
+            settledPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
+        };
+        if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
+            return new _1.BN(-1);
+        const market = this.driftClient.getPerpMarketAccount(proposedPerpPosition.marketIndex);
+        const proposedPerpPositionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, proposedPerpPosition, this.getOracleDataForPerpMarket(market.marketIndex));
+        // total position value after trade
+        const totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedPerpPositionValue);
+        const marginRequirementExcludingTargetMarket = this.getUserAccount().perpPositions.reduce((totalMarginRequirement, position) => {
+            if (position.marketIndex !== perpPosition.marketIndex) {
+                const market = this.driftClient.getPerpMarketAccount(position.marketIndex);
+                const positionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, this.getOracleDataForPerpMarket(market.marketIndex));
+                const marketMarginRequirement = positionValue
+                    .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')))
+                    .div(numericConstants_1.MARGIN_PRECISION);
+                totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
+            }
+            return totalMarginRequirement;
+        }, numericConstants_1.ZERO);
+        const freeCollateralExcludingTargetMarket = totalCollateral.sub(marginRequirementExcludingTargetMarket);
+        // if the position value after the trade is less than free collateral, there is no liq price
+        if (totalPositionValueAfterTrade.lte(freeCollateralExcludingTargetMarket) &&
+            proposedPerpPosition.baseAssetAmount.abs().gt(numericConstants_1.ZERO)) {
+            return new _1.BN(-1);
+        }
+        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedPerpPositionValue
+            .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, proposedPerpPosition.baseAssetAmount.abs(), 'Maintenance')))
+            .div(numericConstants_1.MARGIN_PRECISION));
+        const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
+        const marketMaxLeverage = this.getMaxLeverage(proposedPerpPosition.marketIndex, 'Maintenance');
+        let priceDelta;
+        if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
+            priceDelta = freeCollateralAfterTrade
+                .mul(marketMaxLeverage) // precision is TEN_THOUSAND
+                .div(marketMaxLeverage.add(numericConstants_1.TEN_THOUSAND))
+                .mul(numericConstants_1.PRICE_TO_QUOTE_PRECISION)
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+                .div(proposedBaseAssetAmount);
+        }
+        else {
+            priceDelta = freeCollateralAfterTrade
+                .mul(marketMaxLeverage) // precision is TEN_THOUSAND
+                .div(marketMaxLeverage.sub(numericConstants_1.TEN_THOUSAND))
+                .mul(numericConstants_1.PRICE_TO_QUOTE_PRECISION)
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+                .div(proposedBaseAssetAmount);
+        }
+        let markPriceAfterTrade;
+        if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
+            markPriceAfterTrade = (0, _1.calculateReservePrice)(this.driftClient.getPerpMarketAccount(perpPosition.marketIndex), this.getOracleDataForPerpMarket(perpPosition.marketIndex));
+        }
+        else {
+            const direction = positionBaseSizeChange.gt(numericConstants_1.ZERO)
+                ? _1.PositionDirection.LONG
+                : _1.PositionDirection.SHORT;
+            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.driftClient.getPerpMarketAccount(perpPosition.marketIndex), 'base', this.getOracleDataForPerpMarket(perpPosition.marketIndex))[3]; // newPrice after swap
+        }
+        if (priceDelta.gt(markPriceAfterTrade)) {
+            return new _1.BN(-1);
+        }
+        return markPriceAfterTrade.sub(priceDelta);
+    }
+    /**
+     * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
+     * @param positionMarketIndex
+     * @param closeQuoteAmount
+     * @returns : Precision PRICE_PRECISION
+     */
+    liquidationPriceAfterClose(positionMarketIndex, closeQuoteAmount) {
+        const currentPosition = this.getPerpPosition(positionMarketIndex) ||
+            this.getEmptyPosition(positionMarketIndex);
+        const closeBaseAmount = currentPosition.baseAssetAmount
+            .mul(closeQuoteAmount)
+            .div(currentPosition.quoteAssetAmount.abs())
+            .add(currentPosition.baseAssetAmount
+            .mul(closeQuoteAmount)
+            .mod(currentPosition.quoteAssetAmount.abs()))
+            .neg();
+        return this.liquidationPrice({
+            marketIndex: positionMarketIndex,
+        }, closeBaseAmount);
+    }
+    /**
+     * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
+     *
+     * To Calculate Max Quote Available:
+     *
+     * Case 1: SameSide
+     * 	=> Remaining quote to get to maxLeverage
+     *
+     * Case 2: NOT SameSide && currentLeverage <= maxLeverage
+     * 	=> Current opposite position x2 + remaining to get to maxLeverage
+     *
+     * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
+     * 	=> strictly reduce current position size
+     *
+     * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
+     * 	=> current position + remaining to get to maxLeverage
+     *
+     * @param targetMarketIndex
+     * @param tradeSide
+     * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
+     */
+    getMaxTradeSizeUSDC(targetMarketIndex, tradeSide) {
+        const currentPosition = this.getPerpPosition(targetMarketIndex) ||
+            this.getEmptyPosition(targetMarketIndex);
+        const targetSide = (0, types_1.isVariant)(tradeSide, 'short') ? 'short' : 'long';
+        const currentPositionSide = (currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.baseAssetAmount.isNeg())
+            ? 'short'
+            : 'long';
+        const targetingSameSide = !currentPosition
+            ? true
+            : targetSide === currentPositionSide;
+        const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
+        // add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
+        const oppositeSizeValueUSDC = targetingSameSide
+            ? numericConstants_1.ZERO
+            : this.getPerpPositionValue(targetMarketIndex, oracleData);
+        let maxPositionSize = this.getBuyingPower(targetMarketIndex);
+        if (maxPositionSize.gte(numericConstants_1.ZERO)) {
+            if (oppositeSizeValueUSDC.eq(numericConstants_1.ZERO)) {
+                // case 1 : Regular trade where current total position less than max, and no opposite position to account for
+                // do nothing
+            }
+            else {
+                // case 2 : trade where current total position less than max, but need to account for flipping the current position over to the other side
+                maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC.mul(new _1.BN(2)));
+            }
+        }
+        else {
+            // current leverage is greater than max leverage - can only reduce position size
+            if (!targetingSameSide) {
+                const market = this.driftClient.getPerpMarketAccount(targetMarketIndex);
+                const perpPositionValue = this.getPerpPositionValue(targetMarketIndex, oracleData);
+                const totalCollateral = this.getTotalCollateral();
+                const marginRequirement = this.getInitialMarginRequirement();
+                const marginFreedByClosing = perpPositionValue
+                    .mul(new _1.BN(market.marginRatioInitial))
+                    .div(numericConstants_1.MARGIN_PRECISION);
+                const marginRequirementAfterClosing = marginRequirement.sub(marginFreedByClosing);
+                if (marginRequirementAfterClosing.gt(totalCollateral)) {
+                    maxPositionSize = perpPositionValue;
+                }
+                else {
+                    const freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
+                    const buyingPowerAfterClose = freeCollateralAfterClose
+                        .mul(this.getMaxLeverage(targetMarketIndex))
+                        .div(numericConstants_1.TEN_THOUSAND);
+                    maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
+                }
+            }
+            else {
+                // do nothing if targetting same side
+            }
+        }
+        // subtract oneMillionth of maxPositionSize
+        // => to avoid rounding errors when taking max leverage
+        const oneMilli = maxPositionSize.div(numericConstants_1.QUOTE_PRECISION);
+        return maxPositionSize.sub(oneMilli);
+    }
+    // TODO - should this take the price impact of the trade into account for strict accuracy?
+    /**
+     * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
+     * @param targetMarketIndex
+     * @param positionMarketIndex
+     * @param tradeQuoteAmount
+     * @returns leverageRatio : Precision TEN_THOUSAND
+     */
+    accountLeverageRatioAfterTrade(targetMarketIndex, tradeQuoteAmount, tradeSide, includeOpenOrders = true) {
+        const currentPosition = this.getPerpPosition(targetMarketIndex) ||
+            this.getEmptyPosition(targetMarketIndex);
+        const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
+        let currentPositionQuoteAmount = this.getPerpPositionValue(targetMarketIndex, oracleData);
+        const currentSide = currentPosition && currentPosition.baseAssetAmount.isNeg()
+            ? _1.PositionDirection.SHORT
+            : _1.PositionDirection.LONG;
+        if (currentSide === _1.PositionDirection.SHORT)
+            currentPositionQuoteAmount = currentPositionQuoteAmount.neg();
+        if (tradeSide === _1.PositionDirection.SHORT)
+            tradeQuoteAmount = tradeQuoteAmount.neg();
+        const currentPerpPositionAfterTrade = currentPositionQuoteAmount
+            .add(tradeQuoteAmount)
+            .abs();
+        const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex, undefined, undefined, includeOpenOrders);
+        const totalAssetValue = this.getTotalAssetValue();
+        const totalPerpPositionValue = currentPerpPositionAfterTrade
+            .add(totalPositionAfterTradeExcludingTargetMarket)
+            .abs();
+        const totalLiabilitiesAfterTrade = totalPerpPositionValue.add(this.getSpotMarketLiabilityValue(undefined, undefined, undefined, false));
+        if (totalAssetValue.eq(numericConstants_1.ZERO) && totalLiabilitiesAfterTrade.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        const newLeverage = totalLiabilitiesAfterTrade
+            .mul(numericConstants_1.TEN_THOUSAND)
+            .div(totalAssetValue);
+        return newLeverage;
+    }
+    /**
+     * Calculates how much fee will be taken for a given sized trade
+     * @param quoteAmount
+     * @returns feeForQuote : Precision QUOTE_PRECISION
+     */
+    calculateFeeForQuoteAmount(quoteAmount) {
+        const feeTier = this.driftClient.getStateAccount().perpFeeStructure.feeTiers[0];
+        return quoteAmount
+            .mul(new _1.BN(feeTier.feeNumerator))
+            .div(new _1.BN(feeTier.feeDenominator));
+    }
+    /**
+     * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,
+     * it will return the max withdrawal amount without opening a liability for the user
+     * @param marketIndex
+     * @returns withdrawalLimit : Precision is the token precision for the chosen SpotMarket
+     */
+    getWithdrawalLimit(marketIndex, reduceOnly) {
+        const nowTs = new _1.BN(Math.floor(Date.now() / 1000));
+        const spotMarket = this.driftClient.getSpotMarketAccount(marketIndex);
+        const { borrowLimit, withdrawLimit } = (0, spotBalance_1.calculateWithdrawLimit)(spotMarket, nowTs);
+        const freeCollateral = this.getFreeCollateral();
+        const oracleData = this.getOracleDataForSpotMarket(marketIndex);
+        const precisionIncrease = numericConstants_1.TEN.pow(new _1.BN(spotMarket.decimals - 6));
+        const amountWithdrawable = freeCollateral
+            .mul(numericConstants_1.MARGIN_PRECISION)
+            .div(new _1.BN(spotMarket.initialAssetWeight))
+            .mul(numericConstants_1.PRICE_PRECISION)
+            .div(oracleData.price)
+            .mul(precisionIncrease);
+        const userSpotPosition = this.getUserAccount().spotPositions.find((spotPosition) => (0, types_1.isVariant)(spotPosition.balanceType, 'deposit') &&
+            spotPosition.marketIndex == marketIndex);
+        const userSpotBalance = userSpotPosition
+            ? (0, spotBalance_1.getTokenAmount)(userSpotPosition.scaledBalance, this.driftClient.getSpotMarketAccount(marketIndex), _1.SpotBalanceType.DEPOSIT)
+            : numericConstants_1.ZERO;
+        const maxWithdrawValue = _1.BN.min(_1.BN.min(amountWithdrawable, userSpotBalance), withdrawLimit.abs());
+        if (reduceOnly) {
+            return _1.BN.max(maxWithdrawValue, numericConstants_1.ZERO);
+        }
+        else {
+            const weightedAssetValue = this.getSpotMarketAssetValue(marketIndex, 'Initial', false);
+            const freeCollatAfterWithdraw = userSpotBalance.gt(numericConstants_1.ZERO)
+                ? freeCollateral.sub(weightedAssetValue)
+                : freeCollateral;
+            const maxLiabilityAllowed = freeCollatAfterWithdraw
+                .mul(numericConstants_1.MARGIN_PRECISION)
+                .div(new _1.BN(spotMarket.initialLiabilityWeight))
+                .mul(numericConstants_1.PRICE_PRECISION)
+                .div(oracleData.price)
+                .mul(precisionIncrease);
+            const maxBorrowValue = _1.BN.min(maxWithdrawValue.add(maxLiabilityAllowed), borrowLimit.abs());
+            return _1.BN.max(maxBorrowValue, numericConstants_1.ZERO);
+        }
+    }
+    /**
+     * Get the total position value, excluding any position coming from the given target market
+     * @param marketToIgnore
+     * @returns positionValue : Precision QUOTE_PRECISION
+     */
+    getTotalPerpPositionValueExcludingMarket(marketToIgnore, marginCategory, liquidationBuffer, includeOpenOrders) {
+        const currentPerpPosition = this.getPerpPosition(marketToIgnore) ||
+            this.getEmptyPosition(marketToIgnore);
+        const oracleData = this.getOracleDataForPerpMarket(marketToIgnore);
+        let currentPerpPositionValueUSDC = numericConstants_1.ZERO;
+        if (currentPerpPosition) {
+            currentPerpPositionValueUSDC = this.getPerpPositionValue(marketToIgnore, oracleData);
+        }
+        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders).sub(currentPerpPositionValueUSDC);
+    }
+    getOracleDataForPerpMarket(marketIndex) {
+        const oracleKey = this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
+        const oracleData = this.driftClient.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
+    }
+    getOracleDataForSpotMarket(marketIndex) {
+        const oracleKey = this.driftClient.getSpotMarketAccount(marketIndex).oracle;
+        const oracleData = this.driftClient.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
+    }
+}
+exports.User = User;