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

package/lib/clearingHouseUser.js

@@ -9,6 +9,7 @@ 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;
@@ -212,62 +213,8 @@ class ClearingHouseUser {
     /**
      * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
      */
-    getMarginRequirement(type, liquidationBuffer) {
-        return this.getUserAccount()
-            .perpPositions.reduce((marginRequirement, 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 worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
-            const worstCaseAssetValue = worstCaseBaseAssetAmount
-                .abs()
-                .mul(valuationPrice)
-                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-            const positionMarginRequirement = worstCaseAssetValue
-                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), type)))
-                .div(numericConstants_1.MARGIN_PRECISION);
-            if (liquidationBuffer !== undefined) {
-                positionMarginRequirement.add(worstCaseAssetValue.mul(liquidationBuffer).div(numericConstants_1.MARGIN_PRECISION));
-            }
-            return marginRequirement.add(positionMarginRequirement);
-        }, numericConstants_1.ZERO)
-            .add(this.getSpotMarketLiabilityValue(undefined, type, liquidationBuffer));
+    getMarginRequirement(marginCategory, liquidationBuffer) {
+        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, liquidationBuffer, true));
     }
     /**
      * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
@@ -315,55 +262,127 @@ class ClearingHouseUser {
             return pnl.add((0, _1.calculatePositionFundingPNL)(market, perpPosition));
         }, numericConstants_1.ZERO);
     }
-    getSpotMarketLiabilityValue(marketIndex, withWeightMarginCategory, liquidationBuffer) {
+    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders) {
         return this.getUserAccount().spotPositions.reduce((totalLiabilityValue, spotPosition) => {
-            if (spotPosition.balance.eq(numericConstants_1.ZERO) ||
-                (0, types_1.isVariant)(spotPosition.balanceType, 'deposit') ||
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition) ||
                 (marketIndex !== undefined &&
                     !spotPosition.marketIndex.eq(marketIndex))) {
                 return totalLiabilityValue;
             }
-            // Todo this needs to account for whether it's based on initial or maintenance requirements
             const spotMarketAccount = this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
-            const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
-            let liabilityValue = tokenAmount
-                .mul(this.getOracleDataForSpotMarket(spotMarketAccount.marketIndex).price)
-                .div(numericConstants_1.MARK_PRICE_PRECISION)
-                .div(new _1.BN(10).pow(new _1.BN(spotMarketAccount.decimals).sub(numericConstants_1.SPOT_MARKET_BALANCE_PRECISION_EXP)));
-            if (withWeightMarginCategory !== undefined) {
-                let weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount, spotMarketAccount, withWeightMarginCategory);
-                if (liquidationBuffer !== undefined) {
-                    weight = weight.add(liquidationBuffer);
+            if (spotPosition.marketIndex.eq(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;
                 }
-                liabilityValue = liabilityValue
+            }
+            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 totalLiabilityValue.add(liabilityValue);
+            return newTotalLiabilityValue;
         }, numericConstants_1.ZERO);
     }
-    getSpotMarketAssetValue(marketIndex, withWeightMarginCategory) {
+    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 (spotPosition.balance.eq(numericConstants_1.ZERO) ||
-                (0, types_1.isVariant)(spotPosition.balanceType, 'borrow') ||
+            if ((0, spotPosition_1.isSpotPositionAvailable)(spotPosition) ||
                 (marketIndex !== undefined &&
                     !spotPosition.marketIndex.eq(marketIndex))) {
                 return totalAssetValue;
             }
             // Todo this needs to account for whether it's based on initial or maintenance requirements
             const spotMarketAccount = this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
-            const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType);
-            let assetValue = tokenAmount
-                .mul(this.getOracleDataForSpotMarket(spotMarketAccount.marketIndex).price)
-                .div(numericConstants_1.MARK_PRICE_PRECISION)
-                .div(new _1.BN(10).pow(new _1.BN(spotMarketAccount.decimals).sub(numericConstants_1.SPOT_MARKET_BALANCE_PRECISION_EXP)));
-            if (withWeightMarginCategory !== undefined) {
-                const weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, spotMarketAccount, withWeightMarginCategory);
-                assetValue = assetValue.mul(weight).div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            if (spotPosition.marketIndex.eq(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;
+                }
             }
-            return totalAssetValue.add(assetValue);
+            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;
+                }
+            }
+            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));
     }
@@ -372,24 +391,80 @@ class ClearingHouseUser {
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalCollateral(marginCategory = 'Initial') {
-        return this.getSpotMarketAssetValue(undefined, marginCategory).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+        return this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
     }
     /**
      * calculates sum of position value across all positions in margin system
      * @returns : Precision QUOTE_PRECISION
      */
-    getTotalPositionValue() {
-        return this.getUserAccount().perpPositions.reduce((positionValue, perpPosition) => {
+    getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders) {
+        return this.getUserAccount().perpPositions.reduce((totalPerpValue, perpPosition) => {
             const market = this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
-            const posVal = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, this.getOracleDataForMarket(market.marketIndex));
-            return positionValue.add(posVal);
+            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.MARK_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 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.getPerpMarketAccount(userPosition.marketIndex);
         return (0, margin_1.calculateBaseAssetValueWithOracle)(market, userPosition, oraclePriceData);
@@ -449,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
@@ -475,12 +550,13 @@ 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();
@@ -530,7 +606,7 @@ 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(perpPosition.marketIndex);
+        const totalPositionValueExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(perpPosition.marketIndex);
         const currentPerpPosition = this.getUserPosition(perpPosition.marketIndex) ||
             this.getEmptyPosition(perpPosition.marketIndex);
         const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
@@ -667,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)) {
@@ -683,7 +759,7 @@ class ClearingHouseUser {
             // current leverage is greater than max leverage - can only reduce position size
             if (!targetingSameSide) {
                 const market = this.clearingHouse.getPerpMarketAccount(targetMarketIndex);
-                const perpPositionValue = this.getPositionValue(targetMarketIndex, oracleData);
+                const perpPositionValue = this.getPerpPositionValue(targetMarketIndex, oracleData);
                 const totalCollateral = this.getTotalCollateral();
                 const marginRequirement = this.getInitialMarginRequirement();
                 const marginFreedByClosing = perpPositionValue
@@ -722,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;
@@ -733,7 +809,7 @@ class ClearingHouseUser {
         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 = currentPerpPositionAfterTrade
@@ -763,15 +839,15 @@ class ClearingHouseUser {
      * @param marketToIgnore
      * @returns positionValue : Precision QUOTE_PRECISION
      */
-    getTotalPositionValueExcludingMarket(marketToIgnore) {
+    getTotalPerpPositionValueExcludingMarket(marketToIgnore) {
         const currentPerpPosition = this.getUserPosition(marketToIgnore) ||
             this.getEmptyPosition(marketToIgnore);
         const oracleData = this.getOracleDataForMarket(marketToIgnore);
         let currentPerpPositionValueUSDC = numericConstants_1.ZERO;
         if (currentPerpPosition) {
-            currentPerpPositionValueUSDC = this.getPositionValue(marketToIgnore, oracleData);
+            currentPerpPositionValueUSDC = this.getPerpPositionValue(marketToIgnore, oracleData);
         }
-        return this.getTotalPositionValue().sub(currentPerpPositionValueUSDC);
+        return this.getTotalPerpPositionValue().sub(currentPerpPositionValueUSDC);
     }
     getOracleDataForMarket(marketIndex) {
         const oracleKey = this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;

package/lib/config.js

@@ -7,7 +7,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: '3v1iEjbSSLSSYyt1pmx4UB5rqJGurmz71RibXF7X6UF3',
+        CLEARING_HOUSE_PROGRAM_ID: 'CUowJP5Dea7pkc2mKrkX2RuZUrPXL3u419iBRXyZEWQz',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         PERP_MARKETS: perpMarkets_1.DevnetPerpMarkets,
         SPOT_MARKETS: spotMarkets_1.DevnetSpotMarkets,

package/lib/dlob/DLOB.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="bn.js" />
+import { NodeList } from './NodeList';
+import { MarketType, BN, ClearingHouse, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, UserMap, MarketTypeStr } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { DLOBNode, TriggerOrderNode } from '..';
+export declare type MarketNodeLists = {
+    limit: {
+        ask: NodeList<'limit'>;
+        bid: NodeList<'limit'>;
+    };
+    floatingLimit: {
+        ask: NodeList<'floatingLimit'>;
+        bid: NodeList<'floatingLimit'>;
+    };
+    market: {
+        ask: NodeList<'market'>;
+        bid: NodeList<'market'>;
+    };
+    trigger: {
+        above: NodeList<'trigger'>;
+        below: NodeList<'trigger'>;
+    };
+};
+declare type OrderBookCallback = () => void;
+export declare type NodeToFill = {
+    node: DLOBNode;
+    makerNode?: DLOBNode;
+};
+export declare type NodeToTrigger = {
+    node: TriggerOrderNode;
+};
+declare type Side = 'ask' | 'bid' | 'both';
+export declare class DLOB {
+    openOrders: Map<MarketTypeStr, Set<string>>;
+    orderLists: Map<MarketTypeStr, Map<number, MarketNodeLists>>;
+    marketIndexToAccount: Map<MarketTypeStr, Map<number, PerpMarketAccount | SpotMarketAccount>>;
+    silent: boolean;
+    initialized: boolean;
+    /**
+     *
+     * @param perpMarkets The perp markets to maintain a DLOB for
+     * @param spotMarkets The spot markets to maintain a DLOB for
+     * @param silent set to true to prevent logging on inserts and removals
+     */
+    constructor(perpMarkets: PerpMarketAccount[], spotMarkets: SpotMarketAccount[], silent?: boolean);
+    /**
+     * initializes a new DLOB instance
+     *
+     * @param clearingHouse The ClearingHouse instance to use for price data
+     * @returns a promise that resolves when the DLOB is initialized
+     */
+    init(clearingHouse: ClearingHouse, userMap?: UserMap): Promise<boolean>;
+    insertOrder(order: Order, userAccount: PublicKey, onInsert?: OrderBookCallback): void;
+    trigger(order: Order, userAccount: PublicKey, onTrigger?: OrderBookCallback): void;
+    getListForOrder(order: Order): NodeList<any>;
+    findNodesToFill(marketIndex: BN, vBid: BN | undefined, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    findCrossingNodesToFill(marketIndex: BN, vBid: BN | undefined, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    findMarketNodesToFill(marketIndex: BN, slot: number, marketType: MarketType): NodeToFill[];
+    findJitAuctionNodesToFill(marketIndex: BN, slot: number, marketType: MarketType): NodeToFill[];
+    getMarketBids(marketIndex: BN, marketType: MarketType): Generator<DLOBNode>;
+    getMarketAsks(marketIndex: BN, marketType: MarketType): Generator<DLOBNode>;
+    getAsks(marketIndex: BN, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    getBids(marketIndex: BN, vBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    findCrossingOrders(askNode: DLOBNode, bidNode: DLOBNode, oraclePriceData: OraclePriceData, slot: number): {
+        crossingNodes?: NodeToFill;
+        exhaustedSide?: Side;
+    };
+    getBestAsk(marketIndex: BN, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    getBestBid(marketIndex: BN, vBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    findNodesToTrigger(marketIndex: BN, slot: number, oraclePrice: BN, marketType: MarketType): NodeToTrigger[];
+    printTopOfOrderLists(sdkConfig: any, clearingHouse: ClearingHouse, slotSubscriber: SlotSubscriber, marketIndex: BN, marketType: MarketType): void;
+}
+export {};