@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/lib/clearingHouseUser.js

@@ -1,634 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClearingHouseUser = void 0;
-const types_1 = require("./types");
-const position_1 = require("./math/position");
-const numericConstants_1 = require("./constants/numericConstants");
-const _1 = require(".");
-const bankBalance_1 = require("./math/bankBalance");
-const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
-const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
-class ClearingHouseUser {
-    constructor(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;
-    }
-    get isSubscribed() {
-        return this._isSubscribed && this.accountSubscriber.isSubscribed;
-    }
-    set isSubscribed(val) {
-        this._isSubscribed = val;
-    }
-    /**
-     * Subscribe to ClearingHouseUser 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 market. If the user has no position returns undefined
-     * @param marketIndex
-     * @returns userPosition
-     */
-    getUserPosition(marketIndex) {
-        return this.getUserAccount().positions.find((position) => position.marketIndex.eq(marketIndex));
-    }
-    getEmptyPosition(marketIndex) {
-        return {
-            baseAssetAmount: numericConstants_1.ZERO,
-            lastCumulativeFundingRate: numericConstants_1.ZERO,
-            marketIndex,
-            quoteAssetAmount: numericConstants_1.ZERO,
-            quoteEntryAmount: numericConstants_1.ZERO,
-            openOrders: numericConstants_1.ZERO,
-            unsettledPnl: numericConstants_1.ZERO,
-            openBids: numericConstants_1.ZERO,
-            openAsks: numericConstants_1.ZERO,
-        };
-    }
-    /**
-     * @param orderId
-     * @returns Order
-     */
-    getOrder(orderId) {
-        return this.getUserAccount().orders.find((order) => order.orderId.eq(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.clearingHouse.connection.getParsedAccountInfo(this.userAccountPublicKey);
-        return userAccountRPCResponse.value !== null;
-    }
-    /**
-     * 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;
-    }
-    getInitialMarginRequirement() {
-        return this.getUserAccount()
-            .positions.reduce((marginRequirement, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex))
-                .mul(new _1.BN(market.marginRatioInitial))
-                .div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO)
-            .add(this.getTotalLiability());
-    }
-    /**
-     * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
-     */
-    getMaintenanceMarginRequirement() {
-        return this.getUserAccount()
-            .positions.reduce((marginRequirement, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex))
-                .mul(new _1.BN(market.marginRatioMaintenance))
-                .div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO)
-            .add(this.getTotalLiability());
-    }
-    /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getUnrealizedPNL(withFunding, marketIndex) {
-        return this.getUserAccount()
-            .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
-            .reduce((pnl, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return pnl.add((0, _1.calculatePositionPNL)(market, marketPosition, withFunding, this.getOracleDataForMarket(market.marketIndex)));
-        }, numericConstants_1.ZERO);
-    }
-    /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getUnsettledPNL(marketIndex) {
-        return this.getUserAccount()
-            .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
-            .reduce((pnl, marketPosition) => {
-            return pnl.add(marketPosition.unsettledPnl);
-        }, numericConstants_1.ZERO);
-    }
-    /**
-     * calculates unrealized funding payment pnl
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getUnrealizedFundingPNL(marketIndex) {
-        return this.getUserAccount()
-            .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
-            .reduce((pnl, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return pnl.add((0, _1.calculatePositionFundingPNL)(market, marketPosition));
-        }, numericConstants_1.ZERO);
-    }
-    getTotalLiability() {
-        return this.getUserAccount().bankBalances.reduce((totalAssetValue, bankBalance) => {
-            if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
-                (0, types_1.isVariant)(bankBalance.balanceType, 'deposit')) {
-                return totalAssetValue;
-            }
-            // Todo this needs to account for whether it's based on initial or maintenance requirements
-            const bankAccount = this.clearingHouse.getBankAccount(bankBalance.bankIndex);
-            const tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
-            return totalAssetValue.add(tokenAmount
-                .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .mul(bankAccount.initialLiabilityWeight)
-                .div(numericConstants_1.BANK_WEIGHT_PRECISION)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
-        }, numericConstants_1.ZERO);
-    }
-    getCollateralValue(bankIndex) {
-        return this.getUserAccount().bankBalances.reduce((totalAssetValue, bankBalance) => {
-            if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
-                (bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))) {
-                return totalAssetValue;
-            }
-            // Todo this needs to account for whether it's based on initial or maintenance requirements
-            const bankAccount = this.clearingHouse.getBankAccount(bankBalance.bankIndex);
-            let tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
-            if ((0, types_1.isVariant)(bankBalance.balanceType, 'borrow')) {
-                tokenAmount = tokenAmount.mul(new _1.BN(-1));
-            }
-            return totalAssetValue.add(tokenAmount
-                .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
-        }, numericConstants_1.ZERO);
-    }
-    /**
-     * calculates TotalCollateral: collateral + unrealized pnl
-     * TODO: rename to total equity (for perpetuals swaps)
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getTotalCollateral() {
-        return this.getUserAccount()
-            .bankBalances.reduce((totalAssetValue, bankBalance) => {
-            if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
-                (0, types_1.isVariant)(bankBalance.balanceType, 'borrow')) {
-                return totalAssetValue;
-            }
-            // Todo this needs to account for whether it's based on initial or maintenance requirements
-            const bankAccount = this.clearingHouse.getBankAccount(bankBalance.bankIndex);
-            const tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
-            return totalAssetValue.add(tokenAmount
-                .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .mul(bankAccount.initialAssetWeight)
-                .div(numericConstants_1.BANK_WEIGHT_PRECISION)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
-        }, numericConstants_1.ZERO)
-            .add(this.getUnrealizedPNL(true))
-            .add(this.getUnsettledPNL());
-    }
-    /**
-     * calculates sum of position value across all positions
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getTotalPositionValue() {
-        return this.getUserAccount().positions.reduce((positionValue, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return positionValue.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex)));
-        }, numericConstants_1.ZERO);
-    }
-    /**
-     * calculates position value from closing 100%
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getPositionValue(marketIndex, oraclePriceData) {
-        const userPosition = this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
-        const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
-        return (0, _1.calculateBaseAssetValue)(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 for closing 100% of position
-     * @returns : Precision MARK_PRICE_PRECISION
-     */
-    getPositionEstimatedExitPriceAndPnl(position, amountToClose) {
-        const market = this.clearingHouse.getMarketAccount(position.marketIndex);
-        const entryPrice = (0, position_1.calculateEntryPrice)(position);
-        const 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,
-            };
-        }
-        const baseAssetValue = (0, _1.calculateBaseAssetValue)(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.MARK_PRICE_PRECISION)
-            .div(position.baseAssetAmount.abs());
-        const pnlPerBase = exitPrice.sub(entryPrice);
-        const 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
-     */
-    getLeverage() {
-        const totalCollateral = this.getTotalCollateral();
-        const 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
-     */
-    getMaxLeverage(marketIndex, category = 'Initial') {
-        const market = this.clearingHouse.getMarketAccount(marketIndex);
-        let marginRatioCategory;
-        switch (category) {
-            case 'Initial':
-                marginRatioCategory = market.marginRatioInitial;
-                break;
-            case 'Maintenance':
-                marginRatioCategory = market.marginRatioMaintenance;
-                break;
-            default:
-                marginRatioCategory = market.marginRatioInitial;
-                break;
-        }
-        const 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
-     */
-    getMarginRatio() {
-        const totalPositionValue = this.getTotalPositionValue();
-        if (totalPositionValue.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.BN_MAX;
-        }
-        return this.getTotalCollateral().mul(numericConstants_1.TEN_THOUSAND).div(totalPositionValue);
-    }
-    canBeLiquidated() {
-        const totalCollateral = this.getTotalCollateral();
-        const partialMaintenanceRequirement = this.getMaintenanceMarginRequirement();
-        const marginRatio = this.getMarginRatio();
-        const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
-        return [canLiquidate, marginRatio];
-    }
-    /**
-     * Checks if any user position cumulative funding differs from respective market cumulative funding
-     * @returns
-     */
-    needsToSettleFundingPayment() {
-        for (const userPosition of this.getUserAccount().positions) {
-            if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-                continue;
-            }
-            const market = this.clearingHouse.getMarketAccount(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 marketPosition
-     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
-     * @param partial
-     * @returns Precision : MARK_PRICE_PRECISION
-     */
-    liquidationPrice(marketPosition, 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.getTotalPositionValueExcludingMarket(marketPosition.marketIndex);
-        const currentMarketPosition = this.getUserPosition(marketPosition.marketIndex) ||
-            this.getEmptyPosition(marketPosition.marketIndex);
-        const currentMarketPositionBaseSize = currentMarketPosition.baseAssetAmount;
-        const proposedBaseAssetAmount = currentMarketPositionBaseSize.add(positionBaseSizeChange);
-        // calculate position for current market after trade
-        const proposedMarketPosition = {
-            marketIndex: marketPosition.marketIndex,
-            baseAssetAmount: proposedBaseAssetAmount,
-            lastCumulativeFundingRate: currentMarketPosition.lastCumulativeFundingRate,
-            quoteAssetAmount: new _1.BN(0),
-            quoteEntryAmount: new _1.BN(0),
-            openOrders: new _1.BN(0),
-            unsettledPnl: new _1.BN(0),
-            openBids: new _1.BN(0),
-            openAsks: new _1.BN(0),
-        };
-        if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
-            return new _1.BN(-1);
-        const market = this.clearingHouse.getMarketAccount(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValue = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
-        // total position value after trade
-        const totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
-        const marginRequirementExcludingTargetMarket = this.getUserAccount().positions.reduce((totalMarginRequirement, position) => {
-            if (!position.marketIndex.eq(marketPosition.marketIndex)) {
-                const market = this.clearingHouse.getMarketAccount(position.marketIndex);
-                const positionValue = (0, _1.calculateBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
-                const marketMarginRequirement = positionValue
-                    .mul(new _1.BN(market.marginRatioMaintenance))
-                    .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) &&
-            proposedMarketPosition.baseAssetAmount.abs().gt(numericConstants_1.ZERO)) {
-            return new _1.BN(-1);
-        }
-        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedMarketPositionValue
-            .mul(new _1.BN(market.marginRatioMaintenance))
-            .div(numericConstants_1.MARGIN_PRECISION));
-        const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
-        const marketMaxLeverage = this.getMaxLeverage(proposedMarketPosition.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.calculateMarkPrice)(this.clearingHouse.getMarketAccount(marketPosition.marketIndex), this.getOracleDataForMarket(marketPosition.marketIndex));
-        }
-        else {
-            const direction = positionBaseSizeChange.gt(numericConstants_1.ZERO)
-                ? _1.PositionDirection.LONG
-                : _1.PositionDirection.SHORT;
-            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getMarketAccount(marketPosition.marketIndex), 'base', this.getOracleDataForMarket(marketPosition.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
-     */
-    liquidationPriceAfterClose(positionMarketIndex, closeQuoteAmount) {
-        const currentPosition = this.getUserPosition(positionMarketIndex) ||
-            this.getEmptyPosition(positionMarketIndex);
-        const closeBaseAmount = currentPosition.baseAssetAmount
-            .mul(closeQuoteAmount)
-            .div(currentPosition.quoteAssetAmount)
-            .add(currentPosition.baseAssetAmount
-            .mul(closeQuoteAmount)
-            .mod(currentPosition.quoteAssetAmount))
-            .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.getUserPosition(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.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.
-        const oppositeSizeValueUSDC = targetingSameSide
-            ? numericConstants_1.ZERO
-            : this.getPositionValue(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.clearingHouse.getMarketAccount(targetMarketIndex);
-                const marketPositionValue = this.getPositionValue(targetMarketIndex, oracleData);
-                const totalCollateral = this.getTotalCollateral();
-                const marginRequirement = this.getInitialMarginRequirement();
-                const marginFreedByClosing = marketPositionValue
-                    .mul(new _1.BN(market.marginRatioInitial))
-                    .div(numericConstants_1.MARGIN_PRECISION);
-                const marginRequirementAfterClosing = marginRequirement.sub(marginFreedByClosing);
-                if (marginRequirementAfterClosing.gt(totalCollateral)) {
-                    maxPositionSize = marketPositionValue;
-                }
-                else {
-                    const freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
-                    const buyingPowerAfterClose = freeCollateralAfterClose
-                        .mul(this.getMaxLeverage(targetMarketIndex))
-                        .div(numericConstants_1.TEN_THOUSAND);
-                    maxPositionSize = marketPositionValue.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) {
-        const currentPosition = this.getUserPosition(targetMarketIndex) ||
-            this.getEmptyPosition(targetMarketIndex);
-        const oracleData = this.getOracleDataForMarket(targetMarketIndex);
-        let currentPositionQuoteAmount = this.getPositionValue(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 currentMarketPositionAfterTrade = currentPositionQuoteAmount
-            .add(tradeQuoteAmount)
-            .abs();
-        const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPositionValueExcludingMarket(targetMarketIndex);
-        const totalCollateral = this.getTotalCollateral();
-        if (totalCollateral.gt(numericConstants_1.ZERO)) {
-            const newLeverage = currentMarketPositionAfterTrade
-                .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
-     */
-    calculateFeeForQuoteAmount(quoteAmount) {
-        const feeStructure = this.clearingHouse.getStateAccount().feeStructure;
-        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
-     */
-    getTotalPositionValueExcludingMarket(marketToIgnore) {
-        const currentMarketPosition = this.getUserPosition(marketToIgnore) ||
-            this.getEmptyPosition(marketToIgnore);
-        const oracleData = this.getOracleDataForMarket(marketToIgnore);
-        let currentMarketPositionValueUSDC = numericConstants_1.ZERO;
-        if (currentMarketPosition) {
-            currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore, oracleData);
-        }
-        return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
-    }
-    getOracleDataForMarket(marketIndex) {
-        const oracleKey = this.clearingHouse.getMarketAccount(marketIndex).amm.oracle;
-        const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
-        return oracleData;
-    }
-    getOracleDataForBank(bankIndex) {
-        const oracleKey = this.clearingHouse.getBankAccount(bankIndex).oracle;
-        const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
-        return oracleData;
-    }
-}
-exports.ClearingHouseUser = ClearingHouseUser;

package/lib/clearingHouseUserConfig.d.ts

@@ -1,14 +0,0 @@
-import { ClearingHouse } from './clearingHouse';
-import { PublicKey } from '@solana/web3.js';
-import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-export declare type ClearingHouseUserConfig = {
-    accountSubscription?: ClearingHouseUserAccountSubscriptionConfig;
-    clearingHouse: ClearingHouse;
-    userAccountPublicKey: PublicKey;
-};
-export declare type ClearingHouseUserAccountSubscriptionConfig = {
-    type: 'websocket';
-} | {
-    type: 'polling';
-    accountLoader: BulkAccountLoader;
-};

package/lib/constants/banks.d.ts

@@ -1,16 +0,0 @@
-/// <reference types="bn.js" />
-import { BN, OracleSource } from '../';
-import { DriftEnv } from '../';
-import { PublicKey } from '@solana/web3.js';
-export declare type BankConfig = {
-    symbol: string;
-    bankIndex: BN;
-    oracle: PublicKey;
-    mint: PublicKey;
-    oracleSource: OracleSource;
-};
-export declare const DevnetBanks: BankConfig[];
-export declare const MainnetBanks: BankConfig[];
-export declare const Banks: {
-    [key in DriftEnv]: BankConfig[];
-};