@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/clearingHouseUser.js

@@ -0,0 +1,874 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.ClearingHouseUser = void 0;
+var types_1 = require("./types");
+var position_1 = require("./math/position");
+var numericConstants_1 = require("./constants/numericConstants");
+var _1 = require(".");
+var spotBalance_1 = require("./math/spotBalance");
+var margin_1 = require("./math/margin");
+var pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
+var webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
+var ClearingHouseUser = /** @class */ (function () {
+    function ClearingHouseUser(config) {
+        var _a;
+        this._isSubscribed = false;
+        this.clearingHouse = config.clearingHouse;
+        this.userAccountPublicKey = config.userAccountPublicKey;
+        if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
+            this.accountSubscriber = new pollingUserAccountSubscriber_1.PollingUserAccountSubscriber(config.clearingHouse.program, config.userAccountPublicKey, config.accountSubscription.accountLoader);
+        }
+        else {
+            this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.clearingHouse.program, config.userAccountPublicKey);
+        }
+        this.eventEmitter = this.accountSubscriber.eventEmitter;
+    }
+    Object.defineProperty(ClearingHouseUser.prototype, "isSubscribed", {
+        get: function () {
+            return this._isSubscribed && this.accountSubscriber.isSubscribed;
+        },
+        set: function (val) {
+            this._isSubscribed = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Subscribe to ClearingHouseUser state accounts
+     * @returns SusbcriptionSuccess result
+     */
+    ClearingHouseUser.prototype.subscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, this.accountSubscriber.subscribe()];
+                    case 1:
+                        _a.isSubscribed = _b.sent();
+                        return [2 /*return*/, this.isSubscribed];
+                }
+            });
+        });
+    };
+    /**
+     *	Forces the accountSubscriber to fetch account updates from rpc
+     */
+    ClearingHouseUser.prototype.fetchAccounts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.accountSubscriber.fetch()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouseUser.prototype.unsubscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.accountSubscriber.unsubscribe()];
+                    case 1:
+                        _a.sent();
+                        this.isSubscribed = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouseUser.prototype.getUserAccount = function () {
+        return this.accountSubscriber.getUserAccountAndSlot().data;
+    };
+    ClearingHouseUser.prototype.getUserAccountAndSlot = function () {
+        return this.accountSubscriber.getUserAccountAndSlot();
+    };
+    /**
+     * Gets the user's current position for a given market. If the user has no position returns undefined
+     * @param marketIndex
+     * @returns userPosition
+     */
+    ClearingHouseUser.prototype.getUserPosition = function (marketIndex) {
+        return this.getUserAccount().perpPositions.find(function (position) {
+            return position.marketIndex.eq(marketIndex);
+        });
+    };
+    ClearingHouseUser.prototype.getEmptyPosition = function (marketIndex) {
+        return {
+            baseAssetAmount: numericConstants_1.ZERO,
+            remainderBaseAssetAmount: numericConstants_1.ZERO,
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
+            marketIndex: marketIndex,
+            quoteAssetAmount: numericConstants_1.ZERO,
+            quoteEntryAmount: numericConstants_1.ZERO,
+            openOrders: numericConstants_1.ZERO,
+            openBids: numericConstants_1.ZERO,
+            openAsks: numericConstants_1.ZERO,
+            realizedPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastFeePerLp: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO
+        };
+    };
+    ClearingHouseUser.prototype.getClonedPosition = function (position) {
+        var clonedPosition = Object.assign({}, position);
+        return clonedPosition;
+    };
+    /**
+     * @param orderId
+     * @returns Order
+     */
+    ClearingHouseUser.prototype.getOrder = function (orderId) {
+        return this.getUserAccount().orders.find(function (order) {
+            return order.orderId.eq(orderId);
+        });
+    };
+    /**
+     * @param userOrderId
+     * @returns Order
+     */
+    ClearingHouseUser.prototype.getOrderByUserOrderId = function (userOrderId) {
+        return this.getUserAccount().orders.find(function (order) { return order.userOrderId === userOrderId; });
+    };
+    ClearingHouseUser.prototype.getUserAccountPublicKey = function () {
+        return this.userAccountPublicKey;
+    };
+    ClearingHouseUser.prototype.exists = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountRPCResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.clearingHouse.connection.getParsedAccountInfo(this.userAccountPublicKey)];
+                    case 1:
+                        userAccountRPCResponse = _a.sent();
+                        return [2 /*return*/, userAccountRPCResponse.value !== null];
+                }
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    ClearingHouseUser.prototype.getSettledLPPosition = function (marketIndex) {
+        var _position = this.getUserPosition(marketIndex);
+        var position = this.getClonedPosition(_position);
+        var market = this.clearingHouse.getPerpMarketAccount(position.marketIndex);
+        var nShares = position.lpShares;
+        var deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
+            .sub(position.lastNetBaseAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        var deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+            .sub(position.lastNetQuoteAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        function sign(v) {
+            var sign = { "true": new _1.BN(1), "false": new _1.BN(-1) }[v.gte(numericConstants_1.ZERO).toString()];
+            return sign;
+        }
+        function standardize(amount, stepsize) {
+            var remainder = amount.abs().mod(stepsize).mul(sign(amount));
+            var standardizedAmount = amount.sub(remainder);
+            return [standardizedAmount, remainder];
+        }
+        var _a = standardize(deltaBaa, market.amm.baseAssetAmountStepSize), standardizedBaa = _a[0], remainderBaa = _a[1];
+        position.remainderBaseAssetAmount =
+            position.remainderBaseAssetAmount.add(remainderBaa);
+        if (position.remainderBaseAssetAmount
+            .abs()
+            .gte(market.amm.baseAssetAmountStepSize)) {
+            var _b = standardize(position.remainderBaseAssetAmount, market.amm.baseAssetAmountStepSize), newStandardizedBaa = _b[0], newRemainderBaa = _b[1];
+            position.baseAssetAmount =
+                position.baseAssetAmount.add(newStandardizedBaa);
+            position.remainderBaseAssetAmount = newRemainderBaa;
+        }
+        var 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';
+        }
+        var newQuoteEntry;
+        var 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
+     */
+    ClearingHouseUser.prototype.getBuyingPower = function (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
+     */
+    ClearingHouseUser.prototype.getFreeCollateral = function () {
+        var totalCollateral = this.getTotalCollateral();
+        var initialMarginRequirement = this.getInitialMarginRequirement();
+        var 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
+     */
+    ClearingHouseUser.prototype.getMarginRequirement = function (type) {
+        var _this = this;
+        return this.getUserAccount()
+            .perpPositions.reduce(function (marginRequirement, perpPosition) {
+            var market = _this.clearingHouse.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
+                var _a = _this.getSettledLPPosition(market.marketIndex), settledPosition = _a[0], dustBaa = _a[1], _2 = _a[2];
+                perpPosition.baseAssetAmount =
+                    settledPosition.baseAssetAmount.add(dustBaa);
+                perpPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+                // open orders
+                var openAsks = void 0;
+                if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
+                    openAsks = market.amm.maxBaseAssetReserve
+                        .sub(market.amm.baseAssetReserve)
+                        .mul(perpPosition.lpShares)
+                        .div(market.amm.sqrtK)
+                        .mul(new _1.BN(-1));
+                }
+                else {
+                    openAsks = numericConstants_1.ZERO;
+                }
+                var openBids = void 0;
+                if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
+                    openBids = market.amm.baseAssetReserve
+                        .sub(market.amm.minBaseAssetReserve)
+                        .mul(perpPosition.lpShares)
+                        .div(market.amm.sqrtK);
+                }
+                else {
+                    openBids = numericConstants_1.ZERO;
+                }
+                perpPosition.openAsks = perpPosition.openAsks.add(openAsks);
+                perpPosition.openBids = perpPosition.openBids.add(openBids);
+            }
+            var valuationPrice = _this.getOracleDataForMarket(market.marketIndex).price;
+            if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                valuationPrice = market.settlementPrice;
+            }
+            var worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
+            var worstCaseAssetValue = worstCaseBaseAssetAmount
+                .abs()
+                .mul(valuationPrice)
+                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+            return marginRequirement.add(worstCaseAssetValue
+                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), type)))
+                .div(numericConstants_1.MARGIN_PRECISION));
+        }, numericConstants_1.ZERO)
+            .add(this.getSpotMarketLiabilityValue(undefined, type));
+    };
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getInitialMarginRequirement = function () {
+        return this.getMarginRequirement('Initial');
+    };
+    /**
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getMaintenanceMarginRequirement = function () {
+        return this.getMarginRequirement('Maintenance');
+    };
+    /**
+     * calculates unrealized position price pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getUnrealizedPNL = function (withFunding, marketIndex, withWeightMarginCategory) {
+        var _this = this;
+        return this.getUserAccount()
+            .perpPositions.filter(function (pos) {
+            return marketIndex ? pos.marketIndex === marketIndex : true;
+        })
+            .reduce(function (unrealizedPnl, perpPosition) {
+            var market = _this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
+            var positionUnrealizedPnl = (0, _1.calculatePositionPNL)(market, perpPosition, withFunding, _this.getOracleDataForMarket(market.marketIndex));
+            if (withWeightMarginCategory !== undefined) {
+                if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                    positionUnrealizedPnl = positionUnrealizedPnl
+                        .mul((0, _1.calculateUnrealizedAssetWeight)(market, positionUnrealizedPnl, withWeightMarginCategory))
+                        .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
+     */
+    ClearingHouseUser.prototype.getUnrealizedFundingPNL = function (marketIndex) {
+        var _this = this;
+        return this.getUserAccount()
+            .perpPositions.filter(function (pos) {
+            return marketIndex ? pos.marketIndex === marketIndex : true;
+        })
+            .reduce(function (pnl, perpPosition) {
+            var market = _this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
+            return pnl.add((0, _1.calculatePositionFundingPNL)(market, perpPosition));
+        }, numericConstants_1.ZERO);
+    };
+    ClearingHouseUser.prototype.getSpotMarketLiabilityValue = function (marketIndex, withWeightMarginCategory) {
+        var _this = this;
+        return this.getUserAccount().spotPositions.reduce(function (totalLiabilityValue, spotPosition) {
+            if (spotPosition.balance.eq(numericConstants_1.ZERO) ||
+                (0, types_1.isVariant)(spotPosition.balanceType, 'deposit') ||
+                (marketIndex !== undefined &&
+                    !spotPosition.marketIndex.eq(marketIndex))) {
+                return totalLiabilityValue;
+            }
+            // Todo this needs to account for whether it's based on initial or maintenance requirements
+            var spotMarketAccount = _this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
+            var tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
+            var liabilityValue = tokenAmount
+                .mul(_this.getOracleDataForSpotMarket(spotMarketAccount.marketIndex).price)
+                .div(numericConstants_1.MARK_PRICE_PRECISION)
+                .div(new _1.BN(10).pow(new _1.BN(spotMarketAccount.decimals).sub(numericConstants_1.SPOT_MARKET_BALANCE_PRECISION_EXP)));
+            if (withWeightMarginCategory !== undefined) {
+                var weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount, spotMarketAccount, withWeightMarginCategory);
+                liabilityValue = liabilityValue
+                    .mul(weight)
+                    .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            }
+            return totalLiabilityValue.add(liabilityValue);
+        }, numericConstants_1.ZERO);
+    };
+    ClearingHouseUser.prototype.getSpotMarketAssetValue = function (marketIndex, withWeightMarginCategory) {
+        var _this = this;
+        return this.getUserAccount().spotPositions.reduce(function (totalAssetValue, spotPosition) {
+            if (spotPosition.balance.eq(numericConstants_1.ZERO) ||
+                (0, types_1.isVariant)(spotPosition.balanceType, 'borrow') ||
+                (marketIndex !== undefined &&
+                    !spotPosition.marketIndex.eq(marketIndex))) {
+                return totalAssetValue;
+            }
+            // Todo this needs to account for whether it's based on initial or maintenance requirements
+            var spotMarketAccount = _this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
+            var tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
+            var assetValue = tokenAmount
+                .mul(_this.getOracleDataForSpotMarket(spotMarketAccount.marketIndex).price)
+                .div(numericConstants_1.MARK_PRICE_PRECISION)
+                .div(new _1.BN(10).pow(new _1.BN(spotMarketAccount.decimals).sub(numericConstants_1.SPOT_MARKET_BALANCE_PRECISION_EXP)));
+            if (withWeightMarginCategory !== undefined) {
+                var weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, spotMarketAccount, withWeightMarginCategory);
+                assetValue = assetValue.mul(weight).div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            }
+            return totalAssetValue.add(assetValue);
+        }, numericConstants_1.ZERO);
+    };
+    ClearingHouseUser.prototype.getNetSpotMarketValue = function (withWeightMarginCategory) {
+        return this.getSpotMarketAssetValue(undefined, withWeightMarginCategory).sub(this.getSpotMarketLiabilityValue(undefined, withWeightMarginCategory));
+    };
+    /**
+     * calculates TotalCollateral: collateral + unrealized pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getTotalCollateral = function (marginCategory) {
+        if (marginCategory === void 0) { marginCategory = 'Initial'; }
+        return this.getSpotMarketAssetValue(undefined, marginCategory).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+    };
+    /**
+     * calculates sum of position value across all positions in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getTotalPositionValue = function () {
+        var _this = this;
+        return this.getUserAccount().perpPositions.reduce(function (positionValue, perpPosition) {
+            var market = _this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
+            var posVal = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, _this.getOracleDataForMarket(market.marketIndex));
+            return positionValue.add(posVal);
+        }, numericConstants_1.ZERO);
+    };
+    /**
+     * calculates position value in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getPositionValue = function (marketIndex, oraclePriceData) {
+        var userPosition = this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
+        var market = this.clearingHouse.getPerpMarketAccount(userPosition.marketIndex);
+        return (0, margin_1.calculateBaseAssetValueWithOracle)(market, userPosition, oraclePriceData);
+    };
+    ClearingHouseUser.prototype.getPositionSide = function (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 MARK_PRICE_PRECISION
+     */
+    ClearingHouseUser.prototype.getPositionEstimatedExitPriceAndPnl = function (position, amountToClose, useAMMClose) {
+        if (useAMMClose === void 0) { useAMMClose = false; }
+        var market = this.clearingHouse.getPerpMarketAccount(position.marketIndex);
+        var entryPrice = (0, position_1.calculateEntryPrice)(position);
+        var oraclePriceData = this.getOracleDataForMarket(position.marketIndex);
+        if (amountToClose) {
+            if (amountToClose.eq(numericConstants_1.ZERO)) {
+                return [(0, _1.calculateMarkPrice)(market, oraclePriceData), numericConstants_1.ZERO];
+            }
+            position = {
+                baseAssetAmount: amountToClose,
+                lastCumulativeFundingRate: position.lastCumulativeFundingRate,
+                marketIndex: position.marketIndex,
+                quoteAssetAmount: position.quoteAssetAmount
+            };
+        }
+        var 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];
+        }
+        var exitPrice = baseAssetValue
+            .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .div(position.baseAssetAmount.abs());
+        var pnlPerBase = exitPrice.sub(entryPrice);
+        var pnl = pnlPerBase
+            .mul(position.baseAssetAmount)
+            .div(numericConstants_1.MARK_PRICE_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+        return [exitPrice, pnl];
+    };
+    /**
+     * calculates current user leverage across all positions
+     * @returns : Precision TEN_THOUSAND
+     */
+    ClearingHouseUser.prototype.getLeverage = function () {
+        var totalCollateral = this.getTotalCollateral();
+        var totalPositionValue = this.getTotalPositionValue();
+        if (totalPositionValue.eq(numericConstants_1.ZERO) && totalCollateral.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        return totalPositionValue.mul(numericConstants_1.TEN_THOUSAND).div(totalCollateral);
+    };
+    /**
+     * calculates max allowable leverage exceeding hitting requirement category
+     * @params category {Initial, Partial, Maintenance}
+     * @returns : Precision TEN_THOUSAND
+     */
+    ClearingHouseUser.prototype.getMaxLeverage = function (marketIndex, category) {
+        if (category === void 0) { category = 'Initial'; }
+        var market = this.clearingHouse.getPerpMarketAccount(marketIndex);
+        var marginRatioCategory = (0, _1.calculateMarketMarginRatio)(market, 
+        // worstCaseBaseAssetAmount.abs(),
+        numericConstants_1.ZERO, // todo
+        category);
+        var maxLeverage = numericConstants_1.TEN_THOUSAND.mul(numericConstants_1.TEN_THOUSAND).div(new _1.BN(marginRatioCategory));
+        return maxLeverage;
+    };
+    /**
+     * calculates margin ratio: total collateral / |total position value|
+     * @returns : Precision TEN_THOUSAND
+     */
+    ClearingHouseUser.prototype.getMarginRatio = function () {
+        var totalPositionValue = this.getTotalPositionValue();
+        if (totalPositionValue.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.BN_MAX;
+        }
+        return this.getTotalCollateral().mul(numericConstants_1.TEN_THOUSAND).div(totalPositionValue);
+    };
+    ClearingHouseUser.prototype.canBeLiquidated = function () {
+        var totalCollateral = this.getTotalCollateral();
+        var partialMaintenanceRequirement = this.getMaintenanceMarginRequirement();
+        var marginRatio = this.getMarginRatio();
+        var canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
+        return [canLiquidate, marginRatio];
+    };
+    /**
+     * Checks if any user position cumulative funding differs from respective market cumulative funding
+     * @returns
+     */
+    ClearingHouseUser.prototype.needsToSettleFundingPayment = function () {
+        for (var _i = 0, _a = this.getUserAccount().perpPositions; _i < _a.length; _i++) {
+            var userPosition = _a[_i];
+            if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+                continue;
+            }
+            var market = this.clearingHouse.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 : MARK_PRICE_PRECISION
+     */
+    ClearingHouseUser.prototype.liquidationPrice = function (perpPosition, positionBaseSizeChange) {
+        // solves formula for example canBeLiquidated below
+        var _this = this;
+        if (positionBaseSizeChange === void 0) { positionBaseSizeChange = numericConstants_1.ZERO; }
+        /* 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 */
+        var totalCollateral = this.getTotalCollateral();
+        // calculate the total position value ignoring any value from the target market of the trade
+        var totalPositionValueExcludingTargetMarket = this.getTotalPositionValueExcludingMarket(perpPosition.marketIndex);
+        var currentPerpPosition = this.getUserPosition(perpPosition.marketIndex) ||
+            this.getEmptyPosition(perpPosition.marketIndex);
+        var currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
+        var proposedBaseAssetAmount = currentPerpPositionBaseSize.add(positionBaseSizeChange);
+        // calculate position for current market after trade
+        var proposedPerpPosition = {
+            marketIndex: perpPosition.marketIndex,
+            baseAssetAmount: proposedBaseAssetAmount,
+            remainderBaseAssetAmount: numericConstants_1.ZERO,
+            quoteAssetAmount: new _1.BN(0),
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
+            quoteEntryAmount: new _1.BN(0),
+            openOrders: new _1.BN(0),
+            openBids: new _1.BN(0),
+            openAsks: new _1.BN(0),
+            realizedPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastFeePerLp: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO
+        };
+        if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
+            return new _1.BN(-1);
+        var market = this.clearingHouse.getPerpMarketAccount(proposedPerpPosition.marketIndex);
+        var proposedPerpPositionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, proposedPerpPosition, this.getOracleDataForMarket(market.marketIndex));
+        // total position value after trade
+        var totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedPerpPositionValue);
+        var marginRequirementExcludingTargetMarket = this.getUserAccount().perpPositions.reduce(function (totalMarginRequirement, position) {
+            if (!position.marketIndex.eq(perpPosition.marketIndex)) {
+                var market_1 = _this.clearingHouse.getPerpMarketAccount(position.marketIndex);
+                var positionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market_1, position, _this.getOracleDataForMarket(market_1.marketIndex));
+                var marketMarginRequirement = positionValue
+                    .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market_1, position.baseAssetAmount.abs(), 'Maintenance')))
+                    .div(numericConstants_1.MARGIN_PRECISION);
+                totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
+            }
+            return totalMarginRequirement;
+        }, numericConstants_1.ZERO);
+        var 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);
+        }
+        var marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedPerpPositionValue
+            .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, proposedPerpPosition.baseAssetAmount.abs(), 'Maintenance')))
+            .div(numericConstants_1.MARGIN_PRECISION));
+        var freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
+        var marketMaxLeverage = this.getMaxLeverage(proposedPerpPosition.marketIndex, 'Maintenance');
+        var 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);
+        }
+        var markPriceAfterTrade;
+        if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
+            markPriceAfterTrade = (0, _1.calculateMarkPrice)(this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex), this.getOracleDataForMarket(perpPosition.marketIndex));
+        }
+        else {
+            var direction = positionBaseSizeChange.gt(numericConstants_1.ZERO)
+                ? _1.PositionDirection.LONG
+                : _1.PositionDirection.SHORT;
+            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex), 'base', this.getOracleDataForMarket(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 MARK_PRICE_PRECISION
+     */
+    ClearingHouseUser.prototype.liquidationPriceAfterClose = function (positionMarketIndex, closeQuoteAmount) {
+        var currentPosition = this.getUserPosition(positionMarketIndex) ||
+            this.getEmptyPosition(positionMarketIndex);
+        var 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
+     */
+    ClearingHouseUser.prototype.getMaxTradeSizeUSDC = function (targetMarketIndex, tradeSide) {
+        var currentPosition = this.getUserPosition(targetMarketIndex) ||
+            this.getEmptyPosition(targetMarketIndex);
+        var targetSide = (0, types_1.isVariant)(tradeSide, 'short') ? 'short' : 'long';
+        var currentPositionSide = (currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.baseAssetAmount.isNeg())
+            ? 'short'
+            : 'long';
+        var targetingSameSide = !currentPosition
+            ? true
+            : targetSide === currentPositionSide;
+        var oracleData = this.getOracleDataForMarket(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.
+        var oppositeSizeValueUSDC = targetingSameSide
+            ? numericConstants_1.ZERO
+            : this.getPositionValue(targetMarketIndex, oracleData);
+        var 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) {
+                var market = this.clearingHouse.getPerpMarketAccount(targetMarketIndex);
+                var perpPositionValue = this.getPositionValue(targetMarketIndex, oracleData);
+                var totalCollateral = this.getTotalCollateral();
+                var marginRequirement = this.getInitialMarginRequirement();
+                var marginFreedByClosing = perpPositionValue
+                    .mul(new _1.BN(market.marginRatioInitial))
+                    .div(numericConstants_1.MARGIN_PRECISION);
+                var marginRequirementAfterClosing = marginRequirement.sub(marginFreedByClosing);
+                if (marginRequirementAfterClosing.gt(totalCollateral)) {
+                    maxPositionSize = perpPositionValue;
+                }
+                else {
+                    var freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
+                    var 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
+        var 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
+     */
+    ClearingHouseUser.prototype.accountLeverageRatioAfterTrade = function (targetMarketIndex, tradeQuoteAmount, tradeSide) {
+        var currentPosition = this.getUserPosition(targetMarketIndex) ||
+            this.getEmptyPosition(targetMarketIndex);
+        var oracleData = this.getOracleDataForMarket(targetMarketIndex);
+        var currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex, oracleData);
+        var 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();
+        var currentPerpPositionAfterTrade = currentPositionQuoteAmount
+            .add(tradeQuoteAmount)
+            .abs();
+        var totalPositionAfterTradeExcludingTargetMarket = this.getTotalPositionValueExcludingMarket(targetMarketIndex);
+        var totalCollateral = this.getTotalCollateral();
+        if (totalCollateral.gt(numericConstants_1.ZERO)) {
+            var newLeverage = currentPerpPositionAfterTrade
+                .add(totalPositionAfterTradeExcludingTargetMarket)
+                .abs()
+                .mul(numericConstants_1.TEN_THOUSAND)
+                .div(totalCollateral);
+            return newLeverage;
+        }
+        else {
+            return new _1.BN(0);
+        }
+    };
+    /**
+     * Calculates how much fee will be taken for a given sized trade
+     * @param quoteAmount
+     * @returns feeForQuote : Precision QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.calculateFeeForQuoteAmount = function (quoteAmount) {
+        var feeStructure = this.clearingHouse.getStateAccount().perpFeeStructure;
+        return quoteAmount
+            .mul(feeStructure.feeNumerator)
+            .div(feeStructure.feeDenominator);
+    };
+    /**
+     * Get the total position value, excluding any position coming from the given target market
+     * @param marketToIgnore
+     * @returns positionValue : Precision QUOTE_PRECISION
+     */
+    ClearingHouseUser.prototype.getTotalPositionValueExcludingMarket = function (marketToIgnore) {
+        var currentPerpPosition = this.getUserPosition(marketToIgnore) ||
+            this.getEmptyPosition(marketToIgnore);
+        var oracleData = this.getOracleDataForMarket(marketToIgnore);
+        var currentPerpPositionValueUSDC = numericConstants_1.ZERO;
+        if (currentPerpPosition) {
+            currentPerpPositionValueUSDC = this.getPositionValue(marketToIgnore, oracleData);
+        }
+        return this.getTotalPositionValue().sub(currentPerpPositionValueUSDC);
+    };
+    ClearingHouseUser.prototype.getOracleDataForMarket = function (marketIndex) {
+        var oracleKey = this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;
+        var oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
+    };
+    ClearingHouseUser.prototype.getOracleDataForSpotMarket = function (marketIndex) {
+        var oracleKey = this.clearingHouse.getSpotMarketAccount(marketIndex).oracle;
+        var oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
+    };
+    return ClearingHouseUser;
+}());
+exports.ClearingHouseUser = ClearingHouseUser;