@drift-labs/sdk 0.1.23-master.4 → 0.1.26

package/lib/clearingHouseUser.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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(".");
@@ -136,19 +137,39 @@ class ClearingHouseUser {
      * calculates Buying Power = FC * MAX_LEVERAGE
      * @returns : Precision QUOTE_PRECISION
      */
-    getBuyingPower() {
+    getBuyingPower(marketIndex) {
         return this.getFreeCollateral()
-            .mul(this.getMaxLeverage('Initial'))
+            .mul(this.getMaxLeverage(marketIndex, 'Initial'))
             .div(numericConstants_1.TEN_THOUSAND);
     }
     /**
-     * calculates Free Collateral = (TC - TPV) * MAX_LEVERAGE
+     * calculates Free Collateral = Total collateral - initial margin requirement
      * @returns : Precision QUOTE_PRECISION
      */
     getFreeCollateral() {
-        return this.getTotalCollateral().sub(this.getTotalPositionValue()
-            .mul(numericConstants_1.TEN_THOUSAND)
-            .div(this.getMaxLeverage('Initial')));
+        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.getUserPositionsAccount().positions.reduce((marginRequirement, marketPosition) => {
+            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition)
+                .mul(new _1.BN(market.marginRatioInitial))
+                .div(numericConstants_1.MARGIN_PRECISION));
+        }, numericConstants_1.ZERO);
+    }
+    /**
+     * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getPartialMarginRequirement() {
+        return this.getUserPositionsAccount().positions.reduce((marginRequirement, marketPosition) => {
+            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition)
+                .mul(new _1.BN(market.marginRatioPartial))
+                .div(numericConstants_1.MARGIN_PRECISION));
+        }, numericConstants_1.ZERO);
     }
     /**
      * calculates unrealized position price pnl
@@ -262,24 +283,24 @@ class ClearingHouseUser {
      * @params category {Initial, Partial, Maintenance}
      * @returns : Precision TEN_THOUSAND
      */
-    getMaxLeverage(category) {
-        const chState = this.clearingHouse.getStateAccount();
+    getMaxLeverage(marketIndex, category = 'Initial') {
+        const market = this.clearingHouse.getMarket(marketIndex);
         let marginRatioCategory;
         switch (category) {
             case 'Initial':
-                marginRatioCategory = chState.marginRatioInitial;
+                marginRatioCategory = market.marginRatioInitial;
                 break;
             case 'Maintenance':
-                marginRatioCategory = chState.marginRatioMaintenance;
+                marginRatioCategory = market.marginRatioMaintenance;
                 break;
             case 'Partial':
-                marginRatioCategory = chState.marginRatioPartial;
+                marginRatioCategory = market.marginRatioPartial;
                 break;
             default:
-                marginRatioCategory = chState.marginRatioInitial;
+                marginRatioCategory = market.marginRatioInitial;
                 break;
         }
-        const maxLeverage = numericConstants_1.TEN_THOUSAND.mul(numericConstants_1.TEN_THOUSAND).div(marginRatioCategory);
+        const maxLeverage = numericConstants_1.TEN_THOUSAND.mul(numericConstants_1.TEN_THOUSAND).div(new _1.BN(marginRatioCategory));
         return maxLeverage;
     }
     /**
@@ -294,8 +315,10 @@ class ClearingHouseUser {
         return this.getTotalCollateral().mul(numericConstants_1.TEN_THOUSAND).div(totalPositionValue);
     }
     canBeLiquidated() {
+        const totalCollateral = this.getTotalCollateral();
+        const partialMaintenanceRequirement = this.getPartialMarginRequirement();
         const marginRatio = this.getMarginRatio();
-        const canLiquidate = marginRatio.lte(numericConstants_1.PARTIAL_LIQUIDATION_RATIO);
+        const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
         return [canLiquidate, marginRatio];
     }
     /**
@@ -319,97 +342,13 @@ class ClearingHouseUser {
     }
     /**
      * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
-     * @param targetMarket
+     * @param marketPosition
      * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPriceOld(targetMarket, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
-        // +/-(margin_ratio-liq_ratio) * price_now = price_liq
-        // todo: margin_ratio is not symmetric on price action (both numer and denom change)
-        // margin_ratio = collateral / base_asset_value
-        /* 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 currentPrice = (0, _1.calculateMarkPrice)(this.clearingHouse.getMarket(targetMarket.marketIndex));
-        const totalCollateralUSDC = this.getTotalCollateral();
-        // calculate the total position value ignoring any value from the target market of the trade
-        const totalCurrentPositionValueIgnoringTargetUSDC = this.getTotalPositionValueExcludingMarket(targetMarket.marketIndex);
-        const currentMarketPosition = this.getUserPosition(targetMarket.marketIndex) ||
-            this.getEmptyPosition(targetMarket.marketIndex);
-        const currentMarketPositionBaseSize = currentMarketPosition.baseAssetAmount;
-        // calculate position for current market after trade
-        const proposedMarketPosition = {
-            marketIndex: targetMarket.marketIndex,
-            baseAssetAmount: currentMarketPositionBaseSize.add(positionBaseSizeChange),
-            lastCumulativeFundingRate: new _1.BN(0),
-            quoteAssetAmount: new _1.BN(0),
-            openOrders: new _1.BN(0),
-        };
-        const market = this.clearingHouse.getMarket(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValueUSDC = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition);
-        // total position value after trade
-        const targetTotalPositionValueUSDC = totalCurrentPositionValueIgnoringTargetUSDC.add(proposedMarketPositionValueUSDC);
-        let totalFreeCollateralUSDC = this.getTotalCollateral().sub(this.getTotalPositionValue()
-            .mul(numericConstants_1.TEN_THOUSAND)
-            .div(this.getMaxLeverage('Maintenance')));
-        if (partial) {
-            totalFreeCollateralUSDC = this.getTotalCollateral().sub(this.getTotalPositionValue()
-                .mul(numericConstants_1.TEN_THOUSAND)
-                .div(this.getMaxLeverage('Partial')));
-        }
-        // if the position value after the trade is less than total collateral, there is no liq price
-        if (targetTotalPositionValueUSDC.lte(totalFreeCollateralUSDC) &&
-            proposedMarketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-            return new _1.BN(-1);
-        }
-        // get current margin ratio based on current collateral and proposed total position value
-        let marginRatio;
-        if (proposedMarketPositionValueUSDC.eq(numericConstants_1.ZERO)) {
-            marginRatio = numericConstants_1.BN_MAX;
-        }
-        else {
-            marginRatio = totalCollateralUSDC
-                .mul(numericConstants_1.TEN_THOUSAND)
-                .div(proposedMarketPositionValueUSDC);
-        }
-        let liqRatio = numericConstants_1.FULL_LIQUIDATION_RATIO;
-        if (partial) {
-            liqRatio = numericConstants_1.PARTIAL_LIQUIDATION_RATIO;
-        }
-        // sign of position in current market after the trade
-        const baseAssetSignIsNeg = proposedMarketPosition.baseAssetAmount.isNeg();
-        let pctChange = marginRatio.abs().sub(liqRatio);
-        // if user is short, higher price is liq
-        if (baseAssetSignIsNeg) {
-            pctChange = pctChange.add(numericConstants_1.TEN_THOUSAND);
-        }
-        else {
-            if (numericConstants_1.TEN_THOUSAND.lte(pctChange)) {
-                // no liquidation price, position is a fully/over collateralized long
-                // handle as NaN on UI
-                return new _1.BN(-1);
-            }
-            pctChange = numericConstants_1.TEN_THOUSAND.sub(pctChange);
-        }
-        const liqPrice = currentPrice.mul(pctChange).div(numericConstants_1.TEN_THOUSAND);
-        return liqPrice;
-    }
-    /**
-     * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
-     * @param targetMarket
-     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
-     * @param partial
-     * @returns Precision : MARK_PRICE_PRECISION
-     */
-    liquidationPrice(targetMarket, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
-        // solves formula for example calc below
+    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
+        // 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:
@@ -419,77 +358,86 @@ class ClearingHouseUser {
 
         for 10x long, BTC down $400:
         3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
-        const tc = this.getTotalCollateral();
-        const tpv = this.getTotalPositionValue();
-        const partialLev = 16;
-        const maintLev = 20;
-        const thisLev = partial ? new _1.BN(partialLev) : new _1.BN(maintLev);
+        const totalCollateral = this.getTotalCollateral();
         // calculate the total position value ignoring any value from the target market of the trade
-        const totalCurrentPositionValueIgnoringTargetUSDC = this.getTotalPositionValueExcludingMarket(targetMarket.marketIndex);
-        const currentMarketPosition = this.getUserPosition(targetMarket.marketIndex) ||
-            this.getEmptyPosition(targetMarket.marketIndex);
+        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: targetMarket.marketIndex,
+            marketIndex: marketPosition.marketIndex,
             baseAssetAmount: proposedBaseAssetAmount,
             lastCumulativeFundingRate: currentMarketPosition.lastCumulativeFundingRate,
             quoteAssetAmount: new _1.BN(0),
             openOrders: new _1.BN(0),
         };
+        if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
+            return new _1.BN(-1);
         const market = this.clearingHouse.getMarket(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValueUSDC = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition);
+        const proposedMarketPositionValue = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition);
         // total position value after trade
-        const targetTotalPositionValueUSDC = totalCurrentPositionValueIgnoringTargetUSDC.add(proposedMarketPositionValueUSDC);
-        let totalFreeCollateralUSDC = tc.sub(totalCurrentPositionValueIgnoringTargetUSDC
-            .mul(numericConstants_1.TEN_THOUSAND)
-            .div(this.getMaxLeverage('Maintenance')));
-        if (partial) {
-            totalFreeCollateralUSDC = tc.sub(totalCurrentPositionValueIgnoringTargetUSDC
-                .mul(numericConstants_1.TEN_THOUSAND)
-                .div(this.getMaxLeverage('Partial')));
+        const totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
+        const marginRequirementExcludingTargetMarket = this.getUserPositionsAccount().positions.reduce((totalMarginRequirement, position) => {
+            if (!position.marketIndex.eq(marketPosition.marketIndex)) {
+                const market = this.clearingHouse.getMarket(position.marketIndex);
+                const positionValue = (0, _1.calculateBaseAssetValue)(market, position);
+                const marketMarginRequirement = positionValue
+                    .mul(partial
+                    ? new _1.BN(market.marginRatioPartial)
+                    : 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);
         }
-        let priceDelt;
+        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedMarketPositionValue
+            .mul(partial
+            ? new _1.BN(market.marginRatioPartial)
+            : new _1.BN(market.marginRatioMaintenance))
+            .div(numericConstants_1.MARGIN_PRECISION));
+        const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
+        const marketMaxLeverage = partial
+            ? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
+            : this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+        let priceDelta;
         if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
-            priceDelt = tc
-                .mul(thisLev)
-                .sub(tpv)
+            priceDelta = freeCollateralAfterTrade
+                .mul(marketMaxLeverage) // precision is TEN_THOUSAND
+                .div(marketMaxLeverage.add(numericConstants_1.TEN_THOUSAND))
                 .mul(numericConstants_1.PRICE_TO_QUOTE_PRECISION)
-                .div(thisLev.add(new _1.BN(1)));
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+                .div(proposedBaseAssetAmount);
         }
         else {
-            priceDelt = tc
-                .mul(thisLev)
-                .sub(tpv)
+            priceDelta = freeCollateralAfterTrade
+                .mul(marketMaxLeverage) // precision is TEN_THOUSAND
+                .div(marketMaxLeverage.sub(numericConstants_1.TEN_THOUSAND))
                 .mul(numericConstants_1.PRICE_TO_QUOTE_PRECISION)
-                .div(thisLev.sub(new _1.BN(1)));
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+                .div(proposedBaseAssetAmount);
         }
-        let currentPrice;
+        let markPriceAfterTrade;
         if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
-            currentPrice = (0, _1.calculateMarkPrice)(this.clearingHouse.getMarket(targetMarket.marketIndex));
+            markPriceAfterTrade = (0, _1.calculateMarkPrice)(this.clearingHouse.getMarket(marketPosition.marketIndex));
         }
         else {
             const direction = positionBaseSizeChange.gt(numericConstants_1.ZERO)
                 ? _1.PositionDirection.LONG
                 : _1.PositionDirection.SHORT;
-            currentPrice = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getMarket(targetMarket.marketIndex), 'base')[3]; // newPrice after swap
+            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getMarket(marketPosition.marketIndex), 'base')[3]; // newPrice after swap
         }
-        // if the position value after the trade is less than total collateral, there is no liq price
-        if (targetTotalPositionValueUSDC.lte(totalFreeCollateralUSDC) &&
-            proposedMarketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        if (priceDelta.gt(markPriceAfterTrade)) {
             return new _1.BN(-1);
         }
-        if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
-            return new _1.BN(-1);
-        const eatMargin2 = priceDelt
-            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
-            .div(proposedBaseAssetAmount);
-        if (eatMargin2.gt(currentPrice)) {
-            return new _1.BN(-1);
-        }
-        const liqPrice = currentPrice.sub(eatMargin2);
-        return liqPrice;
+        return markPriceAfterTrade.sub(priceDelta);
     }
     /**
      * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
@@ -530,33 +478,24 @@ class ClearingHouseUser {
      *
      * @param targetMarketIndex
      * @param tradeSide
-     * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
-    getMaxTradeSizeUSDC(targetMarketIndex, tradeSide, userMaxLeverageSetting) {
+    getMaxTradeSizeUSDC(targetMarketIndex, tradeSide) {
         const currentPosition = this.getUserPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
-        const targetSide = tradeSide === _1.PositionDirection.SHORT ? 'short' : 'long';
+        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 targettingSameSide = !currentPosition
+        const targetingSameSide = !currentPosition
             ? true
             : targetSide === currentPositionSide;
         // 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 = targettingSameSide
+        const oppositeSizeValueUSDC = targetingSameSide
             ? numericConstants_1.ZERO
             : this.getPositionValue(targetMarketIndex);
-        // get current leverage
-        const currentLeverage = this.getLeverage();
-        const remainingLeverage = _1.BN.max(userMaxLeverageSetting.sub(currentLeverage), numericConstants_1.ZERO);
-        // get total collateral
-        const totalCollateral = this.getTotalCollateral();
-        // position side allowed based purely on current leverage
-        let maxPositionSize = remainingLeverage
-            .mul(totalCollateral)
-            .div(numericConstants_1.TEN_THOUSAND);
-        if (userMaxLeverageSetting.sub(currentLeverage).gte(numericConstants_1.ZERO)) {
+        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
@@ -568,25 +507,24 @@ class ClearingHouseUser {
         }
         else {
             // current leverage is greater than max leverage - can only reduce position size
-            if (!targettingSameSide) {
-                const currentPositionQuoteSize = this.getPositionValue(targetMarketIndex);
-                const currentTotalQuoteSize = currentLeverage
-                    .mul(totalCollateral)
-                    .div(numericConstants_1.TEN_THOUSAND);
-                const otherPositionsTotalQuoteSize = currentTotalQuoteSize.sub(currentPositionQuoteSize);
-                const quoteValueOfMaxLeverage = userMaxLeverageSetting
-                    .mul(totalCollateral)
-                    .div(numericConstants_1.TEN_THOUSAND);
-                if (otherPositionsTotalQuoteSize
-                    .sub(currentPositionQuoteSize)
-                    .gte(quoteValueOfMaxLeverage)) {
-                    // case 3: Can only reduce the current position because it will still be greater than max leverage
-                    maxPositionSize = currentPositionQuoteSize;
+            if (!targetingSameSide) {
+                const market = this.clearingHouse.getMarket(targetMarketIndex);
+                const marketPositionValue = this.getPositionValue(targetMarketIndex);
+                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 {
-                    // case 4: Can reduce the position, and then take extra remaining quote to get to max leverage
-                    const allowedQuoteSizeAfterClosingCurrentPosition = quoteValueOfMaxLeverage.sub(otherPositionsTotalQuoteSize);
-                    maxPositionSize = currentPositionQuoteSize.add(allowedQuoteSizeAfterClosingCurrentPosition);
+                    const freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
+                    const buyingPowerAfterClose = freeCollateralAfterClose
+                        .mul(this.getMaxLeverage(targetMarketIndex))
+                        .div(numericConstants_1.TEN_THOUSAND);
+                    maxPositionSize = marketPositionValue.add(buyingPowerAfterClose);
                 }
             }
             else {
@@ -659,46 +597,5 @@ class ClearingHouseUser {
         }
         return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
     }
-    canFillOrder(order) {
-        const userAccount = this.getUserAccount();
-        const userPositionsAccount = this.getUserPositionsAccount();
-        const userPosition = this.getUserPosition(order.marketIndex);
-        const market = this.clearingHouse.getMarket(order.marketIndex);
-        if ((0, position_1.isEmptyPosition)(userPosition)) {
-            return false;
-        }
-        const newState = (0, _1.calculateNewStateAfterOrder)(userAccount, userPosition, market, order);
-        if (newState === null) {
-            return false;
-        }
-        const [userAccountAfter, userPositionAfter, marketAfter] = newState;
-        const totalPositionValue = userPositionsAccount.positions.reduce((positionValue, marketPosition) => {
-            let market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            if (marketPosition.marketIndex.eq(order.marketIndex)) {
-                market = marketAfter;
-                marketPosition = userPositionAfter;
-            }
-            return positionValue.add((0, _1.calculateBaseAssetValue)(market, marketPosition));
-        }, numericConstants_1.ZERO);
-        if (totalPositionValue.eq(numericConstants_1.ZERO)) {
-            return true;
-        }
-        const unrealizedPnL = userPositionsAccount.positions.reduce((pnl, marketPosition) => {
-            let market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            pnl = pnl.add((0, _1.calculatePositionFundingPNL)(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION));
-            if (marketPosition.marketIndex.eq(order.marketIndex)) {
-                market = marketAfter;
-                marketPosition = userPositionAfter;
-            }
-            // update
-            return pnl.add((0, _1.calculatePositionPNL)(market, marketPosition, false));
-        }, numericConstants_1.ZERO);
-        const totalCollateral = userAccountAfter.collateral.add(unrealizedPnL);
-        const marginRatioAfter = totalCollateral
-            .mul(numericConstants_1.TEN_THOUSAND)
-            .div(totalPositionValue);
-        const marginRatioInitial = this.clearingHouse.getStateAccount().marginRatioInitial;
-        return marginRatioAfter.gte(marginRatioInitial);
-    }
 }
 exports.ClearingHouseUser = ClearingHouseUser;

package/lib/constants/markets.d.ts

@@ -1,12 +1,14 @@
 /// <reference types="bn.js" />
-import { BN } from '../';
-declare type Market = {
+import { BN, OracleSource } from '../';
+export declare type MarketConfig = {
+    fullName?: string;
+    category?: string[];
     symbol: string;
     baseAssetSymbol: string;
     marketIndex: BN;
     devnetPythOracle: string;
     mainnetPythOracle: string;
     launchTs: number;
+    oracleSource: OracleSource;
 };
-export declare const Markets: Market[];
-export {};
+export declare const Markets: MarketConfig[];

package/lib/constants/markets.js

@@ -4,108 +4,156 @@ exports.Markets = void 0;
 const __1 = require("../");
 exports.Markets = [
     {
+        fullName: 'Solana',
+        category: ['L1', 'Infra'],
         symbol: 'SOL-PERP',
         baseAssetSymbol: 'SOL',
         marketIndex: new __1.BN(0),
         devnetPythOracle: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
         mainnetPythOracle: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
         launchTs: 1635209696886,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Bitcoin',
+        category: ['L1', 'Payment'],
         symbol: 'BTC-PERP',
         baseAssetSymbol: 'BTC',
         marketIndex: new __1.BN(1),
         devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
         mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
         launchTs: 1637691088868,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Ethereum',
+        category: ['L1', 'Infra'],
         symbol: 'ETH-PERP',
         baseAssetSymbol: 'ETH',
         marketIndex: new __1.BN(2),
         devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
         mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
         launchTs: 1637691133472,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Terra',
+        category: ['L1', 'Infra'],
         symbol: 'LUNA-PERP',
         baseAssetSymbol: 'LUNA',
         marketIndex: new __1.BN(3),
         devnetPythOracle: '8PugCXTAHLM9kfLSQWe2njE5pzAgUdpPk3Nx5zSm7BD3',
         mainnetPythOracle: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY',
         launchTs: 1638821738525,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
         symbol: 'AVAX-PERP',
+        category: ['L1', 'Infra'],
         baseAssetSymbol: 'AVAX',
         marketIndex: new __1.BN(4),
         devnetPythOracle: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
         mainnetPythOracle: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
         launchTs: 1639092501080,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Binance Coin',
         symbol: 'BNB-PERP',
+        category: ['L1', 'Exchange'],
         baseAssetSymbol: 'BNB',
         marketIndex: new __1.BN(5),
         devnetPythOracle: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
         mainnetPythOracle: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
         launchTs: 1639523193012,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Polygon',
+        category: ['L1', 'Infra'],
         symbol: 'MATIC-PERP',
         baseAssetSymbol: 'MATIC',
         marketIndex: new __1.BN(6),
         devnetPythOracle: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
         mainnetPythOracle: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
         launchTs: 1641488603564,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Cosmos',
+        category: ['L1', 'Infra'],
         symbol: 'ATOM-PERP',
         baseAssetSymbol: 'ATOM',
         marketIndex: new __1.BN(7),
         devnetPythOracle: '7YAze8qFUMkBnyLVdKT4TFUUFui99EwS5gfRArMcrvFk',
         mainnetPythOracle: 'CrCpTerNqtZvqLcKqz1k13oVeXV9WkMD2zA9hBKXrsbN',
         launchTs: 1641920238195,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Polkadot',
         symbol: 'DOT-PERP',
         baseAssetSymbol: 'DOT',
         marketIndex: new __1.BN(8),
         devnetPythOracle: '4dqq5VBpN4EwYb7wyywjjfknvMKu7m78j9mKZRXTj462',
         mainnetPythOracle: 'EcV1X1gY2yb4KXxjVQtTHTbioum2gvmPnFk4zYAt7zne',
         launchTs: 1642629253786,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Cardano',
+        category: ['L1', 'Infra'],
         symbol: 'ADA-PERP',
         baseAssetSymbol: 'ADA',
         marketIndex: new __1.BN(9),
         devnetPythOracle: '8oGTURNmSQkrBS1AQ5NjB2p8qY34UVmMA9ojrw8vnHus',
         mainnetPythOracle: '3pyn4svBbxJ9Wnn3RVeafyLWfzie6yC5eTig2S62v9SC',
         launchTs: 1643084413000,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Algorand',
+        category: ['L1', 'Infra'],
         symbol: 'ALGO-PERP',
         baseAssetSymbol: 'ALGO',
         marketIndex: new __1.BN(10),
         devnetPythOracle: 'c1A946dY5NHuVda77C8XXtXytyR3wK1SCP3eA9VRfC3',
         mainnetPythOracle: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
         launchTs: 1643686767000,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'FTX Coin',
+        category: ['L1', 'Exchange'],
         symbol: 'FTT-PERP',
         baseAssetSymbol: 'FTT',
         marketIndex: new __1.BN(11),
         devnetPythOracle: '6vivTRs5ZPeeXbjo7dfburfaYDWoXjBtdtuYgQRuGfu',
         mainnetPythOracle: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
         launchTs: 1644382122000,
+        oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Litecoin',
+        category: ['L1', 'Payments'],
         symbol: 'LTC-PERP',
         baseAssetSymbol: 'LTC',
         marketIndex: new __1.BN(12),
         devnetPythOracle: 'BLArYBCUYhdWiY8PCUTpvFE21iaJq85dvxLk9bYMobcU',
         mainnetPythOracle: '8RMnV1eD55iqUFJLMguPkYBkq8DCtx81XcmAja93LvRR',
         launchTs: 1645027429000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+    {
+        fullName: 'Ripple',
+        category: ['L1', 'Payments'],
+        symbol: 'XRP-PERP',
+        baseAssetSymbol: 'XRP',
+        marketIndex: new __1.BN(13),
+        devnetPythOracle: 'WMW5xc3HypXwTnPesyUT49uLsyHwNURsWAEk39onKuk',
+        mainnetPythOracle: 'WMW5xc3HypXwTnPesyUT49uLsyHwNURsWAEk39onKuk',
+        launchTs: 1647543166000,
+        oracleSource: __1.OracleSource.SWITCHBOARD,
     },
     // {
     // 	symbol: 'mSOL-PERP',

package/lib/constants/numericConstants.d.ts

@@ -3,11 +3,10 @@ import { BN } from '../';
 export declare const ZERO: BN;
 export declare const ONE: BN;
 export declare const TWO: BN;
+export declare const TEN: BN;
 export declare const TEN_THOUSAND: BN;
 export declare const BN_MAX: BN;
 export declare const MAX_LEVERAGE: BN;
-export declare const FULL_LIQUIDATION_RATIO: BN;
-export declare const PARTIAL_LIQUIDATION_RATIO: BN;
 export declare const QUOTE_PRECISION: BN;
 export declare const MARK_PRICE_PRECISION: BN;
 export declare const FUNDING_PAYMENT_PRECISION: BN;
@@ -17,3 +16,4 @@ export declare const BASE_PRECISION: BN;
 export declare const AMM_TO_QUOTE_PRECISION_RATIO: BN;
 export declare const PRICE_TO_QUOTE_PRECISION: BN;
 export declare const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO: BN;
+export declare const MARGIN_PRECISION: BN;