@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.30

package/lib/clearingHouseUser.js

@@ -5,9 +5,11 @@ 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 spotBalance_1 = require("./math/spotBalance");
+const margin_1 = require("./math/margin");
 const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
 const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
+const spotPosition_1 = require("./math/spotPosition");
 class ClearingHouseUser {
     constructor(config) {
         var _a;
@@ -58,21 +60,30 @@ class ClearingHouseUser {
      * @returns userPosition
      */
     getUserPosition(marketIndex) {
-        return this.getUserAccount().positions.find((position) => position.marketIndex.eq(marketIndex));
+        return this.getUserAccount().perpPositions.find((position) => position.marketIndex === marketIndex);
     }
     getEmptyPosition(marketIndex) {
         return {
             baseAssetAmount: numericConstants_1.ZERO,
+            remainderBaseAssetAmount: numericConstants_1.ZERO,
             lastCumulativeFundingRate: numericConstants_1.ZERO,
             marketIndex,
             quoteAssetAmount: numericConstants_1.ZERO,
             quoteEntryAmount: numericConstants_1.ZERO,
-            openOrders: numericConstants_1.ZERO,
-            unsettledPnl: numericConstants_1.ZERO,
+            openOrders: 0,
             openBids: numericConstants_1.ZERO,
             openAsks: numericConstants_1.ZERO,
+            settledPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastFeePerLp: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
     }
+    getClonedPosition(position) {
+        const clonedPosition = Object.assign({}, position);
+        return clonedPosition;
+    }
     /**
      * @param orderId
      * @returns Order
@@ -94,6 +105,92 @@ class ClearingHouseUser {
         const userAccountRPCResponse = await this.clearingHouse.connection.getParsedAccountInfo(this.userAccountPublicKey);
         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
+     */
+    getSettledLPPosition(marketIndex) {
+        const _position = this.getUserPosition(marketIndex);
+        const position = this.getClonedPosition(_position);
+        const market = this.clearingHouse.getPerpMarketAccount(position.marketIndex);
+        const nShares = position.lpShares;
+        const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
+            .sub(position.lastNetBaseAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        const deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+            .sub(position.lastNetQuoteAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        function sign(v) {
+            const sign = { true: new _1.BN(1), false: new _1.BN(-1) }[v.gte(numericConstants_1.ZERO).toString()];
+            return sign;
+        }
+        function standardize(amount, stepsize) {
+            const remainder = amount.abs().mod(stepsize).mul(sign(amount));
+            const standardizedAmount = amount.sub(remainder);
+            return [standardizedAmount, remainder];
+        }
+        const [standardizedBaa, remainderBaa] = standardize(deltaBaa, market.amm.baseAssetAmountStepSize);
+        position.remainderBaseAssetAmount =
+            position.remainderBaseAssetAmount.add(remainderBaa);
+        if (position.remainderBaseAssetAmount
+            .abs()
+            .gte(market.amm.baseAssetAmountStepSize)) {
+            const [newStandardizedBaa, newRemainderBaa] = standardize(position.remainderBaseAssetAmount, market.amm.baseAssetAmountStepSize);
+            position.baseAssetAmount =
+                position.baseAssetAmount.add(newStandardizedBaa);
+            position.remainderBaseAssetAmount = newRemainderBaa;
+        }
+        let updateType;
+        if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+            updateType = 'open';
+        }
+        else if (sign(position.baseAssetAmount).eq(sign(deltaBaa))) {
+            updateType = 'increase';
+        }
+        else if (position.baseAssetAmount.abs().gt(deltaBaa.abs())) {
+            updateType = 'reduce';
+        }
+        else if (position.baseAssetAmount.abs().eq(deltaBaa.abs())) {
+            updateType = 'close';
+        }
+        else {
+            updateType = 'flip';
+        }
+        let newQuoteEntry;
+        let pnl;
+        if (updateType == 'open' || updateType == 'increase') {
+            newQuoteEntry = position.quoteEntryAmount.add(deltaQaa);
+            pnl = 0;
+        }
+        else if (updateType == 'reduce' || updateType == 'close') {
+            newQuoteEntry = position.quoteEntryAmount.sub(position.quoteEntryAmount
+                .mul(deltaBaa.abs())
+                .div(position.baseAssetAmount.abs()));
+            pnl = position.quoteEntryAmount.sub(newQuoteEntry).add(deltaQaa);
+        }
+        else {
+            newQuoteEntry = deltaQaa.sub(deltaQaa.mul(position.baseAssetAmount.abs()).div(deltaBaa.abs()));
+            pnl = position.quoteEntryAmount.add(deltaQaa.sub(newQuoteEntry));
+        }
+        position.quoteEntryAmount = newQuoteEntry;
+        position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
+        position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
+        if (position.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+            position.lastCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+        }
+        else if (position.baseAssetAmount.lt(numericConstants_1.ZERO)) {
+            position.lastCumulativeFundingRate =
+                market.amm.cumulativeFundingRateShort;
+        }
+        else {
+            position.lastCumulativeFundingRate = numericConstants_1.ZERO;
+        }
+        return [position, remainderBaa, pnl];
+    }
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
      * @returns : Precision QUOTE_PRECISION
@@ -113,50 +210,44 @@ class ClearingHouseUser {
         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 margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+     */
+    getMarginRequirement(marginCategory, liquidationBuffer) {
+        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, liquidationBuffer, true));
     }
     /**
-     * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getPartialMarginRequirement() {
-        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.marginRatioPartial))
-                .div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO)
-            .add(this.getTotalLiability());
+    getInitialMarginRequirement() {
+        return this.getMarginRequirement('Initial');
     }
     /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
+     * @returns The maintenance margin requirement in USDC. : 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);
+    getMaintenanceMarginRequirement(liquidationBuffer) {
+        return this.getMarginRequirement('Maintenance', liquidationBuffer);
     }
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getUnsettledPNL(marketIndex) {
+    getUnrealizedPNL(withFunding, marketIndex, withWeightMarginCategory) {
+        const quoteSpotMarket = this.clearingHouse.getQuoteSpotMarketAccount();
         return this.getUserAccount()
-            .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
-            .reduce((pnl, marketPosition) => {
-            return pnl.add(marketPosition.unsettledPnl);
+            .perpPositions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
+            .reduce((unrealizedPnl, perpPosition) => {
+            const market = this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
+            const oraclePriceData = this.getOracleDataForMarket(market.marketIndex);
+            let positionUnrealizedPnl = (0, _1.calculatePositionPNL)(market, perpPosition, withFunding, oraclePriceData);
+            if (withWeightMarginCategory !== undefined) {
+                if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                    positionUnrealizedPnl = positionUnrealizedPnl
+                        .mul((0, _1.calculateUnrealizedAssetWeight)(market, quoteSpotMarket, positionUnrealizedPnl, withWeightMarginCategory, oraclePriceData))
+                        .div(new _1.BN(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION));
+                }
+            }
+            return unrealizedPnl.add(positionUnrealizedPnl);
         }, numericConstants_1.ZERO);
     }
     /**
@@ -165,87 +256,218 @@ class ClearingHouseUser {
      */
     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));
+            .perpPositions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
+            .reduce((pnl, perpPosition) => {
+            const market = this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
+            return pnl.add((0, _1.calculatePositionFundingPNL)(market, perpPosition));
         }, 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;
+    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders) {
+        return this.getUserAccount().spotPositions.reduce((totalLiabilityValue, spotPosition) => {
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition) ||
+                (marketIndex !== undefined &&
+                    spotPosition.marketIndex !== marketIndex)) {
+                return totalLiabilityValue;
             }
-            // 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));
+            const spotMarketAccount = this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'borrow')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
+                    let weight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
+                    if (marginCategory === 'Initial') {
+                        weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().customMarginRatio));
+                    }
+                    const weightedTokenValue = tokenAmount
+                        .mul(weight)
+                        .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+                    return totalLiabilityValue.add(weightedTokenValue);
+                }
+                else {
+                    return totalLiabilityValue;
+                }
+            }
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            if (!includeOpenOrders) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'borrow')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
+                    const liabilityValue = this.getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer);
+                    return totalLiabilityValue.add(liabilityValue);
+                }
+                else {
+                    return totalLiabilityValue;
+                }
+            }
+            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, this.getOracleDataForSpotMarket(spotPosition.marketIndex));
+            let newTotalLiabilityValue = totalLiabilityValue;
+            if (worstCaseTokenAmount.lt(numericConstants_1.ZERO)) {
+                const baseLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer);
+                newTotalLiabilityValue =
+                    newTotalLiabilityValue.add(baseLiabilityValue);
+            }
+            if (worstCaseQuoteTokenAmount.lt(numericConstants_1.ZERO)) {
+                let weight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
+                if (marginCategory === 'Initial') {
+                    weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().customMarginRatio));
+                }
+                const weightedTokenValue = worstCaseQuoteTokenAmount
+                    .mul(weight)
+                    .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+                newTotalLiabilityValue =
+                    newTotalLiabilityValue.add(weightedTokenValue);
+            }
+            return newTotalLiabilityValue;
         }, 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))) {
+    getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer) {
+        let liabilityValue = (0, _1.getTokenValue)(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+        if (marginCategory !== undefined) {
+            let weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount, spotMarketAccount, marginCategory);
+            if (marginCategory === 'Initial') {
+                weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().customMarginRatio));
+            }
+            if (liquidationBuffer !== undefined) {
+                weight = weight.add(liquidationBuffer);
+            }
+            liabilityValue = liabilityValue
+                .mul(weight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+        }
+        return liabilityValue;
+    }
+    getSpotMarketAssetValue(marketIndex, marginCategory, includeOpenOrders) {
+        return this.getUserAccount().spotPositions.reduce((totalAssetValue, spotPosition) => {
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition) ||
+                (marketIndex !== undefined &&
+                    spotPosition.marketIndex !== marketIndex)) {
                 return totalAssetValue;
             }
             // Todo this needs to account for whether it's based on initial or maintenance requirements
-            const 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));
+            const spotMarketAccount = this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'deposit')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
+                    return totalAssetValue.add(tokenAmount);
+                }
+                else {
+                    return totalAssetValue;
+                }
+            }
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            if (!includeOpenOrders) {
+                if ((0, types_1.isVariant)(spotPosition.balanceType, 'deposit')) {
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
+                    const assetValue = this.getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory);
+                    return totalAssetValue.add(assetValue);
+                }
+                else {
+                    return totalAssetValue;
+                }
             }
-            return totalAssetValue.add(tokenAmount
-                .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
+            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, this.getOracleDataForSpotMarket(spotPosition.marketIndex));
+            let newTotalAssetValue = totalAssetValue;
+            if (worstCaseTokenAmount.gt(numericConstants_1.ZERO)) {
+                const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory);
+                newTotalAssetValue = newTotalAssetValue.add(baseAssetValue);
+            }
+            if (worstCaseQuoteTokenAmount.gt(numericConstants_1.ZERO)) {
+                newTotalAssetValue = newTotalAssetValue.add(worstCaseQuoteTokenAmount);
+            }
+            return newTotalAssetValue;
         }, numericConstants_1.ZERO);
     }
+    getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory) {
+        let assetValue = (0, _1.getTokenValue)(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+        if (marginCategory !== undefined) {
+            const weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, spotMarketAccount, marginCategory);
+            assetValue = assetValue.mul(weight).div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+        }
+        return assetValue;
+    }
+    getNetSpotMarketValue(withWeightMarginCategory) {
+        return this.getSpotMarketAssetValue(undefined, withWeightMarginCategory).sub(this.getSpotMarketLiabilityValue(undefined, withWeightMarginCategory));
+    }
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
-     * 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());
+    getTotalCollateral(marginCategory = 'Initial') {
+        return this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
     }
     /**
-     * calculates sum of position value across all positions
+     * calculates sum of position value across all positions in margin system
      * @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)));
+    getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders) {
+        return this.getUserAccount().perpPositions.reduce((totalPerpValue, perpPosition) => {
+            const 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
+                const [settledPosition, dustBaa, _] = this.getSettledLPPosition(market.marketIndex);
+                perpPosition.baseAssetAmount =
+                    settledPosition.baseAssetAmount.add(dustBaa);
+                perpPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+                // open orders
+                let openAsks;
+                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;
+                }
+                let openBids;
+                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);
+            }
+            let valuationPrice = this.getOracleDataForMarket(market.marketIndex).price;
+            if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                valuationPrice = market.settlementPrice;
+            }
+            const baseAssetAmount = includeOpenOrders
+                ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
+                : perpPosition.baseAssetAmount;
+            let baseAssetValue = baseAssetAmount
+                .abs()
+                .mul(valuationPrice)
+                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
+            if (marginCategory) {
+                let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
+                if (marginCategory === 'Initial') {
+                    marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().customMarginRatio));
+                }
+                if (liquidationBuffer !== undefined) {
+                    marginRatio = marginRatio.add(liquidationBuffer);
+                }
+                baseAssetValue = baseAssetValue
+                    .mul(marginRatio)
+                    .div(numericConstants_1.MARGIN_PRECISION);
+            }
+            return totalPerpValue.add(baseAssetValue);
         }, numericConstants_1.ZERO);
     }
     /**
-     * calculates position value from closing 100%
+     * calculates position value in margin system
      * @returns : Precision QUOTE_PRECISION
      */
-    getPositionValue(marketIndex, oraclePriceData) {
+    getPerpPositionValue(marketIndex, oraclePriceData) {
         const userPosition = this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
-        const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
-        return (0, _1.calculateBaseAssetValue)(market, userPosition, oraclePriceData);
+        const market = this.clearingHouse.getPerpMarketAccount(userPosition.marketIndex);
+        return (0, margin_1.calculateBaseAssetValueWithOracle)(market, userPosition, oraclePriceData);
     }
     getPositionSide(currentPosition) {
         if (currentPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
@@ -259,16 +481,16 @@ class ClearingHouseUser {
         }
     }
     /**
-     * calculates average exit price for closing 100% of position
-     * @returns : Precision MARK_PRICE_PRECISION
+     * calculates average exit price (optionally for closing up to 100% of position)
+     * @returns : Precision PRICE_PRECISION
      */
-    getPositionEstimatedExitPriceAndPnl(position, amountToClose) {
-        const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+    getPositionEstimatedExitPriceAndPnl(position, amountToClose, useAMMClose = false) {
+        const market = this.clearingHouse.getPerpMarketAccount(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];
+                return [(0, _1.calculateReservePrice)(market, oraclePriceData), numericConstants_1.ZERO];
             }
             position = {
                 baseAssetAmount: amountToClose,
@@ -277,18 +499,24 @@ class ClearingHouseUser {
                 quoteAssetAmount: position.quoteAssetAmount,
             };
         }
-        const baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
+        let baseAssetValue;
+        if (useAMMClose) {
+            baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
+        }
+        else {
+            baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, oraclePriceData);
+        }
         if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
             return [numericConstants_1.ZERO, numericConstants_1.ZERO];
         }
         const exitPrice = baseAssetValue
             .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(numericConstants_1.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.PRICE_PRECISION)
             .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
         return [exitPrice, pnl];
     }
@@ -296,13 +524,13 @@ class ClearingHouseUser {
      * 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)) {
+    getLeverage(marginCategory) {
+        const totalLiabilityValue = this.getTotalPerpPositionValue(marginCategory, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, undefined, true));
+        const totalAssetValue = this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+        if (totalAssetValue.eq(numericConstants_1.ZERO) && totalLiabilityValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
-        return totalPositionValue.mul(numericConstants_1.TEN_THOUSAND).div(totalCollateral);
+        return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(totalAssetValue);
     }
     /**
      * calculates max allowable leverage exceeding hitting requirement category
@@ -310,22 +538,11 @@ class ClearingHouseUser {
      * @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;
-            case 'Partial':
-                marginRatioCategory = market.marginRatioPartial;
-                break;
-            default:
-                marginRatioCategory = market.marginRatioInitial;
-                break;
-        }
+        const market = this.clearingHouse.getPerpMarketAccount(marketIndex);
+        const marginRatioCategory = (0, _1.calculateMarketMarginRatio)(market, 
+        // worstCaseBaseAssetAmount.abs(),
+        numericConstants_1.ZERO, // todo
+        category);
         const maxLeverage = numericConstants_1.TEN_THOUSAND.mul(numericConstants_1.TEN_THOUSAND).div(new _1.BN(marginRatioCategory));
         return maxLeverage;
     }
@@ -333,30 +550,34 @@ class ClearingHouseUser {
      * calculates margin ratio: total collateral / |total position value|
      * @returns : Precision TEN_THOUSAND
      */
-    getMarginRatio() {
-        const totalPositionValue = this.getTotalPositionValue();
-        if (totalPositionValue.eq(numericConstants_1.ZERO)) {
+    getMarginRatio(marginCategory) {
+        const totalLiabilityValue = this.getTotalPerpPositionValue(marginCategory, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, undefined, true));
+        if (totalLiabilityValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.BN_MAX;
         }
-        return this.getTotalCollateral().mul(numericConstants_1.TEN_THOUSAND).div(totalPositionValue);
+        const totalAssetValue = this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+        return totalAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
     }
     canBeLiquidated() {
         const totalCollateral = this.getTotalCollateral();
-        const partialMaintenanceRequirement = this.getPartialMarginRequirement();
-        const marginRatio = this.getMarginRatio();
-        const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
-        return [canLiquidate, marginRatio];
+        // if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
+        let liquidationBuffer = undefined;
+        if (this.getUserAccount().beingLiquidated) {
+            liquidationBuffer = new _1.BN(this.clearingHouse.getStateAccount().liquidationMarginBufferRatio);
+        }
+        const maintenanceRequirement = this.getMaintenanceMarginRequirement(liquidationBuffer);
+        return totalCollateral.lt(maintenanceRequirement);
     }
     /**
      * Checks if any user position cumulative funding differs from respective market cumulative funding
      * @returns
      */
     needsToSettleFundingPayment() {
-        for (const userPosition of this.getUserAccount().positions) {
+        for (const userPosition of this.getUserAccount().perpPositions) {
             if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
                 continue;
             }
-            const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
+            const market = this.clearingHouse.getPerpMarketAccount(userPosition.marketIndex);
             if (market.amm.cumulativeFundingRateLong.eq(userPosition.lastCumulativeFundingRate) ||
                 market.amm.cumulativeFundingRateShort.eq(userPosition.lastCumulativeFundingRate)) {
                 continue;
@@ -367,12 +588,12 @@ class ClearingHouseUser {
     }
     /**
      * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
-     * @param marketPosition
+     * @param PerpPosition
      * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
      * @param partial
-     * @returns Precision : MARK_PRICE_PRECISION
+     * @returns Precision : PRICE_PRECISION
      */
-    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
+    liquidationPrice(perpPosition, positionBaseSizeChange = numericConstants_1.ZERO) {
         // solves formula for example canBeLiquidated below
         /* example: assume BTC price is $40k (examine 10% up/down)
 
@@ -385,37 +606,40 @@ class ClearingHouseUser {
         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);
+        const totalPositionValueExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(perpPosition.marketIndex);
+        const currentPerpPosition = this.getUserPosition(perpPosition.marketIndex) ||
+            this.getEmptyPosition(perpPosition.marketIndex);
+        const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
+        const proposedBaseAssetAmount = currentPerpPositionBaseSize.add(positionBaseSizeChange);
         // calculate position for current market after trade
-        const proposedMarketPosition = {
-            marketIndex: marketPosition.marketIndex,
+        const proposedPerpPosition = {
+            marketIndex: perpPosition.marketIndex,
             baseAssetAmount: proposedBaseAssetAmount,
-            lastCumulativeFundingRate: currentMarketPosition.lastCumulativeFundingRate,
+            remainderBaseAssetAmount: numericConstants_1.ZERO,
             quoteAssetAmount: new _1.BN(0),
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
             quoteEntryAmount: new _1.BN(0),
-            openOrders: new _1.BN(0),
-            unsettledPnl: new _1.BN(0),
+            openOrders: 0,
             openBids: new _1.BN(0),
             openAsks: new _1.BN(0),
+            settledPnl: 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);
-        const market = this.clearingHouse.getMarketAccount(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValue = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
+        const market = this.clearingHouse.getPerpMarketAccount(proposedPerpPosition.marketIndex);
+        const proposedPerpPositionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, proposedPerpPosition, 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 totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedPerpPositionValue);
+        const marginRequirementExcludingTargetMarket = this.getUserAccount().perpPositions.reduce((totalMarginRequirement, position) => {
+            if (position.marketIndex !== perpPosition.marketIndex) {
+                const market = this.clearingHouse.getPerpMarketAccount(position.marketIndex);
+                const positionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, this.getOracleDataForMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
-                    .mul(partial
-                    ? new _1.BN(market.marginRatioPartial)
-                    : new _1.BN(market.marginRatioMaintenance))
+                    .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')))
                     .div(numericConstants_1.MARGIN_PRECISION);
                 totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
             }
@@ -424,18 +648,14 @@ class ClearingHouseUser {
         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)) {
+            proposedPerpPosition.baseAssetAmount.abs().gt(numericConstants_1.ZERO)) {
             return new _1.BN(-1);
         }
-        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedMarketPositionValue
-            .mul(partial
-            ? new _1.BN(market.marginRatioPartial)
-            : new _1.BN(market.marginRatioMaintenance))
+        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedPerpPositionValue
+            .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, proposedPerpPosition.baseAssetAmount.abs(), 'Maintenance')))
             .div(numericConstants_1.MARGIN_PRECISION));
         const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
-        const marketMaxLeverage = partial
-            ? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-            : this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+        const marketMaxLeverage = this.getMaxLeverage(proposedPerpPosition.marketIndex, 'Maintenance');
         let priceDelta;
         if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
             priceDelta = freeCollateralAfterTrade
@@ -455,13 +675,13 @@ class ClearingHouseUser {
         }
         let markPriceAfterTrade;
         if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
-            markPriceAfterTrade = (0, _1.calculateMarkPrice)(this.clearingHouse.getMarketAccount(marketPosition.marketIndex), this.getOracleDataForMarket(marketPosition.marketIndex));
+            markPriceAfterTrade = (0, _1.calculateReservePrice)(this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex), this.getOracleDataForMarket(perpPosition.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
+            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);
@@ -472,21 +692,21 @@ class ClearingHouseUser {
      * 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
+     * @returns : Precision PRICE_PRECISION
      */
     liquidationPriceAfterClose(positionMarketIndex, closeQuoteAmount) {
         const currentPosition = this.getUserPosition(positionMarketIndex) ||
             this.getEmptyPosition(positionMarketIndex);
         const closeBaseAmount = currentPosition.baseAssetAmount
             .mul(closeQuoteAmount)
-            .div(currentPosition.quoteAssetAmount)
+            .div(currentPosition.quoteAssetAmount.abs())
             .add(currentPosition.baseAssetAmount
             .mul(closeQuoteAmount)
-            .mod(currentPosition.quoteAssetAmount))
+            .mod(currentPosition.quoteAssetAmount.abs()))
             .neg();
         return this.liquidationPrice({
             marketIndex: positionMarketIndex,
-        }, closeBaseAmount, true);
+        }, closeBaseAmount);
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
@@ -523,7 +743,7 @@ class ClearingHouseUser {
         // 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);
+            : this.getPerpPositionValue(targetMarketIndex, oracleData);
         let maxPositionSize = this.getBuyingPower(targetMarketIndex);
         if (maxPositionSize.gte(numericConstants_1.ZERO)) {
             if (oppositeSizeValueUSDC.eq(numericConstants_1.ZERO)) {
@@ -538,23 +758,23 @@ class ClearingHouseUser {
         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 market = this.clearingHouse.getPerpMarketAccount(targetMarketIndex);
+                const perpPositionValue = this.getPerpPositionValue(targetMarketIndex, oracleData);
                 const totalCollateral = this.getTotalCollateral();
                 const marginRequirement = this.getInitialMarginRequirement();
-                const marginFreedByClosing = marketPositionValue
+                const marginFreedByClosing = perpPositionValue
                     .mul(new _1.BN(market.marginRatioInitial))
                     .div(numericConstants_1.MARGIN_PRECISION);
                 const marginRequirementAfterClosing = marginRequirement.sub(marginFreedByClosing);
                 if (marginRequirementAfterClosing.gt(totalCollateral)) {
-                    maxPositionSize = marketPositionValue;
+                    maxPositionSize = perpPositionValue;
                 }
                 else {
                     const freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
                     const buyingPowerAfterClose = freeCollateralAfterClose
                         .mul(this.getMaxLeverage(targetMarketIndex))
                         .div(numericConstants_1.TEN_THOUSAND);
-                    maxPositionSize = marketPositionValue.add(buyingPowerAfterClose);
+                    maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
                 }
             }
             else {
@@ -578,7 +798,7 @@ class ClearingHouseUser {
         const currentPosition = this.getUserPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
         const oracleData = this.getOracleDataForMarket(targetMarketIndex);
-        let currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex, oracleData);
+        let currentPositionQuoteAmount = this.getPerpPositionValue(targetMarketIndex, oracleData);
         const currentSide = currentPosition && currentPosition.baseAssetAmount.isNeg()
             ? _1.PositionDirection.SHORT
             : _1.PositionDirection.LONG;
@@ -586,13 +806,13 @@ class ClearingHouseUser {
             currentPositionQuoteAmount = currentPositionQuoteAmount.neg();
         if (tradeSide === _1.PositionDirection.SHORT)
             tradeQuoteAmount = tradeQuoteAmount.neg();
-        const currentMarketPositionAfterTrade = currentPositionQuoteAmount
+        const currentPerpPositionAfterTrade = currentPositionQuoteAmount
             .add(tradeQuoteAmount)
             .abs();
-        const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPositionValueExcludingMarket(targetMarketIndex);
+        const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex);
         const totalCollateral = this.getTotalCollateral();
         if (totalCollateral.gt(numericConstants_1.ZERO)) {
-            const newLeverage = currentMarketPositionAfterTrade
+            const newLeverage = currentPerpPositionAfterTrade
                 .add(totalPositionAfterTradeExcludingTargetMarket)
                 .abs()
                 .mul(numericConstants_1.TEN_THOUSAND)
@@ -609,33 +829,33 @@ class ClearingHouseUser {
      * @returns feeForQuote : Precision QUOTE_PRECISION
      */
     calculateFeeForQuoteAmount(quoteAmount) {
-        const feeStructure = this.clearingHouse.getStateAccount().feeStructure;
+        const feeTier = this.clearingHouse.getStateAccount().perpFeeStructure.feeTiers[0];
         return quoteAmount
-            .mul(feeStructure.feeNumerator)
-            .div(feeStructure.feeDenominator);
+            .mul(new _1.BN(feeTier.feeNumerator))
+            .div(new _1.BN(feeTier.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) ||
+    getTotalPerpPositionValueExcludingMarket(marketToIgnore) {
+        const currentPerpPosition = this.getUserPosition(marketToIgnore) ||
             this.getEmptyPosition(marketToIgnore);
         const oracleData = this.getOracleDataForMarket(marketToIgnore);
-        let currentMarketPositionValueUSDC = numericConstants_1.ZERO;
-        if (currentMarketPosition) {
-            currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore, oracleData);
+        let currentPerpPositionValueUSDC = numericConstants_1.ZERO;
+        if (currentPerpPosition) {
+            currentPerpPositionValueUSDC = this.getPerpPositionValue(marketToIgnore, oracleData);
         }
-        return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
+        return this.getTotalPerpPositionValue().sub(currentPerpPositionValueUSDC);
     }
     getOracleDataForMarket(marketIndex) {
-        const oracleKey = this.clearingHouse.getMarketAccount(marketIndex).amm.oracle;
+        const oracleKey = this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;
         const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
         return oracleData;
     }
-    getOracleDataForBank(bankIndex) {
-        const oracleKey = this.clearingHouse.getBankAccount(bankIndex).oracle;
+    getOracleDataForSpotMarket(marketIndex) {
+        const oracleKey = this.clearingHouse.getSpotMarketAccount(marketIndex).oracle;
         const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
         return oracleData;
     }