@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.33

package/lib/clearingHouseConfig.d.ts

@@ -10,8 +10,8 @@ export declare type ClearingHouseConfig = {
     accountSubscription?: ClearingHouseSubscriptionConfig;
     opts?: ConfirmOptions;
     txSenderConfig?: TxSenderConfig;
-    userIds?: number[];
-    activeUserId?: number;
+    subAccountIds?: number[];
+    activeSubAccountId?: number;
     perpMarketIndexes?: number[];
     spotMarketIndexes?: number[];
     oracleInfos?: OracleInfo[];

package/lib/clearingHouseUser.d.ts

@@ -50,6 +50,18 @@ export declare class ClearingHouseUser {
     getOrderByUserOrderId(userOrderId: number): Order | undefined;
     getUserAccountPublicKey(): PublicKey;
     exists(): Promise<boolean>;
+    /**
+     * calculates the total open bids/asks in a perp market (including lps)
+     * @returns : open bids
+     * @returns : open asks
+     */
+    getPerpBidAsks(marketIndex: number): [BN, BN];
+    /**
+     * calculates the open bids and asks for an lp
+     * @returns : lp open bids
+     * @returns : lp open asks
+     */
+    getLPBidAsks(marketIndex: number): [BN, BN];
     /**
      * calculates the market position if the lp position was settled
      * @returns : the settled userPosition
@@ -119,10 +131,12 @@ export declare class ClearingHouseUser {
      * calculates current user leverage across all positions
      * @returns : Precision TEN_THOUSAND
      */
-    getLeverage(marginCategory?: MarginCategory): BN;
+    getLeverage(): BN;
+    getTotalLiabilityValue(): BN;
+    getTotalAssetValue(): BN;
     /**
      * calculates max allowable leverage exceeding hitting requirement category
-     * @params category {Initial, Partial, Maintenance}
+     * @params category {Initial, Maintenance}
      * @returns : Precision TEN_THOUSAND
      */
     getMaxLeverage(marketIndex: number, category?: MarginCategory): BN;
@@ -130,7 +144,7 @@ export declare class ClearingHouseUser {
      * calculates margin ratio: total collateral / |total position value|
      * @returns : Precision TEN_THOUSAND
      */
-    getMarginRatio(marginCategory?: MarginCategory): BN;
+    getMarginRatio(): BN;
     canBeLiquidated(): boolean;
     /**
      * Checks if any user position cumulative funding differs from respective market cumulative funding
@@ -181,19 +195,26 @@ export declare class ClearingHouseUser {
      * @param tradeQuoteAmount
      * @returns leverageRatio : Precision TEN_THOUSAND
      */
-    accountLeverageRatioAfterTrade(targetMarketIndex: number, tradeQuoteAmount: BN, tradeSide: PositionDirection): BN;
+    accountLeverageRatioAfterTrade(targetMarketIndex: number, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
     /**
      * Calculates how much fee will be taken for a given sized trade
      * @param quoteAmount
      * @returns feeForQuote : Precision QUOTE_PRECISION
      */
     calculateFeeForQuoteAmount(quoteAmount: BN): BN;
+    /**
+     * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,
+     * it will return the max withdrawal amount without opening a liability for the user
+     * @param marketIndex
+     * @returns withdrawalLimit : Precision is the token precision for the chosen SpotMarket
+     */
+    getWithdrawalLimit(marketIndex: number, reduceOnly?: boolean): BN;
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore
      * @returns positionValue : Precision QUOTE_PRECISION
      */
     private getTotalPerpPositionValueExcludingMarket;
-    private getOracleDataForMarket;
+    private getOracleDataForPerpMarket;
     private getOracleDataForSpotMarket;
 }

package/lib/clearingHouseUser.js

@@ -6,6 +6,7 @@ const position_1 = require("./math/position");
 const numericConstants_1 = require("./constants/numericConstants");
 const _1 = require(".");
 const spotBalance_1 = require("./math/spotBalance");
+const amm_1 = require("./math/amm");
 const margin_1 = require("./math/margin");
 const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
 const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
@@ -104,6 +105,38 @@ class ClearingHouseUser {
         const userAccountRPCResponse = await this.clearingHouse.connection.getParsedAccountInfo(this.userAccountPublicKey);
         return userAccountRPCResponse.value !== null;
     }
+    /**
+     * calculates the total open bids/asks in a perp market (including lps)
+     * @returns : open bids
+     * @returns : open asks
+     */
+    getPerpBidAsks(marketIndex) {
+        const position = this.getUserPosition(marketIndex);
+        const [lpOpenBids, lpOpenAsks] = this.getLPBidAsks(marketIndex);
+        const totalOpenBids = lpOpenBids.add(position.openBids);
+        const totalOpenAsks = lpOpenAsks.sub(position.openAsks);
+        return [totalOpenBids, totalOpenAsks];
+    }
+    /**
+     * calculates the open bids and asks for an lp
+     * @returns : lp open bids
+     * @returns : lp open asks
+     */
+    getLPBidAsks(marketIndex) {
+        const position = this.getUserPosition(marketIndex);
+        if (position.lpShares.eq(numericConstants_1.ZERO)) {
+            return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const market = this.clearingHouse.getPerpMarketAccount(marketIndex);
+        const [marketOpenBids, marketOpenAsks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve);
+        const lpOpenBids = marketOpenBids
+            .mul(position.lpShares)
+            .div(market.amm.sqrtK);
+        const lpOpenAsks = marketOpenAsks
+            .mul(position.lpShares)
+            .div(market.amm.sqrtK);
+        return [lpOpenBids, lpOpenAsks];
+    }
     /**
      * calculates the market position if the lp position was settled
      * @returns : the settled userPosition
@@ -113,13 +146,16 @@ class ClearingHouseUser {
     getSettledLPPosition(marketIndex) {
         const _position = this.getUserPosition(marketIndex);
         const position = this.getClonedPosition(_position);
+        if (position.lpShares.eq(numericConstants_1.ZERO)) {
+            return [position, numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
         const market = this.clearingHouse.getPerpMarketAccount(position.marketIndex);
         const nShares = position.lpShares;
-        const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
+        const deltaBaa = market.amm.baseAssetAmountPerLp
             .sub(position.lastNetBaseAssetAmountPerLp)
             .mul(nShares)
             .div(numericConstants_1.AMM_RESERVE_PRECISION);
-        const deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+        const deltaQaa = market.amm.quoteAssetAmountPerLp
             .sub(position.lastNetQuoteAssetAmountPerLp)
             .mul(nShares)
             .div(numericConstants_1.AMM_RESERVE_PRECISION);
@@ -132,11 +168,11 @@ class ClearingHouseUser {
             const standardizedAmount = amount.sub(remainder);
             return [standardizedAmount, remainder];
         }
-        const [standardizedBaa, remainderBaa] = standardize(deltaBaa, market.amm.baseAssetAmountStepSize);
+        const [standardizedBaa, remainderBaa] = standardize(deltaBaa, market.amm.orderStepSize);
         position.remainderBaseAssetAmount += remainderBaa.toNumber();
         if (Math.abs(position.remainderBaseAssetAmount) >
-            market.amm.baseAssetAmountStepSize.toNumber()) {
-            const [newStandardizedBaa, newRemainderBaa] = standardize(position.remainderBaseAssetAmount, market.amm.baseAssetAmountStepSize);
+            market.amm.orderStepSize.toNumber()) {
+            const [newStandardizedBaa, newRemainderBaa] = standardize(new _1.BN(position.remainderBaseAssetAmount), market.amm.orderStepSize);
             position.baseAssetAmount =
                 position.baseAssetAmount.add(newStandardizedBaa);
             position.remainderBaseAssetAmount = newRemainderBaa.toNumber();
@@ -235,7 +271,7 @@ class ClearingHouseUser {
             .perpPositions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
             .reduce((unrealizedPnl, perpPosition) => {
             const market = this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex);
-            const oraclePriceData = this.getOracleDataForMarket(market.marketIndex);
+            const oraclePriceData = this.getOracleDataForPerpMarket(market.marketIndex);
             let positionUnrealizedPnl = (0, _1.calculatePositionPNL)(market, perpPosition, withFunding, oraclePriceData);
             if (withWeightMarginCategory !== undefined) {
                 if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
@@ -269,10 +305,10 @@ class ClearingHouseUser {
             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);
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, 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));
+                        weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
                     }
                     const weightedTokenValue = tokenAmount
                         .mul(weight)
@@ -286,7 +322,7 @@ class ClearingHouseUser {
             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 tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
                     const liabilityValue = this.getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer);
                     return totalLiabilityValue.add(liabilityValue);
                 }
@@ -304,7 +340,7 @@ class ClearingHouseUser {
             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));
+                    weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
                 }
                 const weightedTokenValue = worstCaseQuoteTokenAmount
                     .abs()
@@ -321,7 +357,7 @@ class ClearingHouseUser {
         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));
+                weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
             }
             if (liquidationBuffer !== undefined) {
                 weight = weight.add(liquidationBuffer);
@@ -343,7 +379,7 @@ class ClearingHouseUser {
             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);
+                    const tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
                     return totalAssetValue.add(tokenAmount);
                 }
                 else {
@@ -353,7 +389,7 @@ class ClearingHouseUser {
             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 tokenAmount = (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
                     const assetValue = this.getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory);
                     return totalAssetValue.add(assetValue);
                 }
@@ -432,9 +468,9 @@ class ClearingHouseUser {
                 perpPosition.openAsks = perpPosition.openAsks.add(openAsks);
                 perpPosition.openBids = perpPosition.openBids.add(openBids);
             }
-            let valuationPrice = this.getOracleDataForMarket(market.marketIndex).price;
+            let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
             if ((0, types_1.isVariant)(market.status, 'settlement')) {
-                valuationPrice = market.settlementPrice;
+                valuationPrice = market.expiryPrice;
             }
             const baseAssetAmount = includeOpenOrders
                 ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
@@ -446,11 +482,14 @@ class ClearingHouseUser {
             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));
+                    marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
                 }
                 if (liquidationBuffer !== undefined) {
                     marginRatio = marginRatio.add(liquidationBuffer);
                 }
+                if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                    marginRatio = numericConstants_1.ZERO;
+                }
                 baseAssetValue = baseAssetValue
                     .mul(marginRatio)
                     .div(numericConstants_1.MARGIN_PRECISION);
@@ -485,7 +524,7 @@ class ClearingHouseUser {
     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);
+        const oraclePriceData = this.getOracleDataForPerpMarket(position.marketIndex);
         if (amountToClose) {
             if (amountToClose.eq(numericConstants_1.ZERO)) {
                 return [(0, _1.calculateReservePrice)(market, oraclePriceData), numericConstants_1.ZERO];
@@ -522,45 +561,63 @@ class ClearingHouseUser {
      * calculates current user leverage across all positions
      * @returns : Precision TEN_THOUSAND
      */
-    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));
+    getLeverage() {
+        const totalLiabilityValue = this.getTotalLiabilityValue();
+        const totalAssetValue = this.getTotalAssetValue();
         if (totalAssetValue.eq(numericConstants_1.ZERO) && totalLiabilityValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
         return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(totalAssetValue);
     }
+    getTotalLiabilityValue() {
+        return this.getTotalPerpPositionValue(undefined, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true));
+    }
+    getTotalAssetValue() {
+        return this.getSpotMarketAssetValue(undefined, undefined, true).add(this.getUnrealizedPNL(true, undefined, undefined));
+    }
     /**
      * calculates max allowable leverage exceeding hitting requirement category
-     * @params category {Initial, Partial, Maintenance}
+     * @params category {Initial, Maintenance}
      * @returns : Precision TEN_THOUSAND
      */
     getMaxLeverage(marketIndex, category = 'Initial') {
         const market = this.clearingHouse.getPerpMarketAccount(marketIndex);
-        const marginRatioCategory = (0, _1.calculateMarketMarginRatio)(market, 
+        const totalAssetValue = this.getTotalAssetValue();
+        if (totalAssetValue.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        const totalLiabilityValue = this.getTotalLiabilityValue();
+        const marginRatio = (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;
+        const freeCollateral = this.getFreeCollateral();
+        // how much more liabilities can be opened w remaining free collateral
+        const additionalLiabilities = freeCollateral
+            .mul(numericConstants_1.MARGIN_PRECISION)
+            .div(new _1.BN(marginRatio));
+        return totalLiabilityValue
+            .add(additionalLiabilities)
+            .mul(numericConstants_1.TEN_THOUSAND)
+            .div(totalAssetValue);
     }
     /**
      * calculates margin ratio: total collateral / |total position value|
      * @returns : Precision TEN_THOUSAND
      */
-    getMarginRatio(marginCategory) {
-        const totalLiabilityValue = this.getTotalPerpPositionValue(marginCategory, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, undefined, true));
+    getMarginRatio() {
+        const totalLiabilityValue = this.getTotalLiabilityValue();
         if (totalLiabilityValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.BN_MAX;
         }
-        const totalAssetValue = this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+        const totalAssetValue = this.getTotalAssetValue();
         return totalAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
     }
     canBeLiquidated() {
         const totalCollateral = this.getTotalCollateral();
         // 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) {
+        if (this.getUserAccount().isBeingLiquidated) {
             liquidationBuffer = new _1.BN(this.clearingHouse.getStateAccount().liquidationMarginBufferRatio);
         }
         const maintenanceRequirement = this.getMaintenanceMarginRequirement(liquidationBuffer);
@@ -628,13 +685,13 @@ class ClearingHouseUser {
         if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
             return new _1.BN(-1);
         const market = this.clearingHouse.getPerpMarketAccount(proposedPerpPosition.marketIndex);
-        const proposedPerpPositionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, proposedPerpPosition, this.getOracleDataForMarket(market.marketIndex));
+        const proposedPerpPositionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, proposedPerpPosition, this.getOracleDataForPerpMarket(market.marketIndex));
         // total position value after trade
         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 positionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, this.getOracleDataForPerpMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
                     .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')))
                     .div(numericConstants_1.MARGIN_PRECISION);
@@ -672,13 +729,13 @@ class ClearingHouseUser {
         }
         let markPriceAfterTrade;
         if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
-            markPriceAfterTrade = (0, _1.calculateReservePrice)(this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex), this.getOracleDataForMarket(perpPosition.marketIndex));
+            markPriceAfterTrade = (0, _1.calculateReservePrice)(this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex), this.getOracleDataForPerpMarket(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.getPerpMarketAccount(perpPosition.marketIndex), 'base', this.getOracleDataForMarket(perpPosition.marketIndex))[3]; // newPrice after swap
+            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex), 'base', this.getOracleDataForPerpMarket(perpPosition.marketIndex))[3]; // newPrice after swap
         }
         if (priceDelta.gt(markPriceAfterTrade)) {
             return new _1.BN(-1);
@@ -736,7 +793,7 @@ class ClearingHouseUser {
         const targetingSameSide = !currentPosition
             ? true
             : targetSide === currentPositionSide;
-        const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+        const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
         // add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
         const oppositeSizeValueUSDC = targetingSameSide
             ? numericConstants_1.ZERO
@@ -791,10 +848,10 @@ class ClearingHouseUser {
      * @param tradeQuoteAmount
      * @returns leverageRatio : Precision TEN_THOUSAND
      */
-    accountLeverageRatioAfterTrade(targetMarketIndex, tradeQuoteAmount, tradeSide) {
+    accountLeverageRatioAfterTrade(targetMarketIndex, tradeQuoteAmount, tradeSide, includeOpenOrders = true) {
         const currentPosition = this.getUserPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
-        const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+        const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
         let currentPositionQuoteAmount = this.getPerpPositionValue(targetMarketIndex, oracleData);
         const currentSide = currentPosition && currentPosition.baseAssetAmount.isNeg()
             ? _1.PositionDirection.SHORT
@@ -806,19 +863,19 @@ class ClearingHouseUser {
         const currentPerpPositionAfterTrade = currentPositionQuoteAmount
             .add(tradeQuoteAmount)
             .abs();
-        const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex);
-        const totalCollateral = this.getTotalCollateral();
-        if (totalCollateral.gt(numericConstants_1.ZERO)) {
-            const newLeverage = currentPerpPositionAfterTrade
-                .add(totalPositionAfterTradeExcludingTargetMarket)
-                .abs()
-                .mul(numericConstants_1.TEN_THOUSAND)
-                .div(totalCollateral);
-            return newLeverage;
-        }
-        else {
-            return new _1.BN(0);
+        const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex, undefined, undefined, includeOpenOrders);
+        const totalAssetValue = this.getTotalAssetValue();
+        const totalPerpPositionValue = currentPerpPositionAfterTrade
+            .add(totalPositionAfterTradeExcludingTargetMarket)
+            .abs();
+        const totalLiabilitiesAfterTrade = totalPerpPositionValue.add(this.getSpotMarketLiabilityValue(undefined, undefined, undefined, false));
+        if (totalAssetValue.eq(numericConstants_1.ZERO) && totalLiabilitiesAfterTrade.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
         }
+        const newLeverage = totalLiabilitiesAfterTrade
+            .mul(numericConstants_1.TEN_THOUSAND)
+            .div(totalAssetValue);
+        return newLeverage;
     }
     /**
      * Calculates how much fee will be taken for a given sized trade
@@ -831,22 +888,65 @@ class ClearingHouseUser {
             .mul(new _1.BN(feeTier.feeNumerator))
             .div(new _1.BN(feeTier.feeDenominator));
     }
+    /**
+     * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,
+     * it will return the max withdrawal amount without opening a liability for the user
+     * @param marketIndex
+     * @returns withdrawalLimit : Precision is the token precision for the chosen SpotMarket
+     */
+    getWithdrawalLimit(marketIndex, reduceOnly) {
+        const nowTs = new _1.BN(Math.floor(Date.now() / 1000));
+        const spotMarket = this.clearingHouse.getSpotMarketAccount(marketIndex);
+        const { borrowLimit, withdrawLimit } = (0, spotBalance_1.calculateWithdrawLimit)(spotMarket, nowTs);
+        const freeCollateral = this.getFreeCollateral();
+        const oracleData = this.getOracleDataForSpotMarket(marketIndex);
+        const precisionIncrease = numericConstants_1.TEN.pow(new _1.BN(spotMarket.decimals - 6));
+        const amountWithdrawable = freeCollateral
+            .mul(numericConstants_1.MARGIN_PRECISION)
+            .div(spotMarket.initialAssetWeight)
+            .mul(numericConstants_1.PRICE_PRECISION)
+            .div(oracleData.price)
+            .mul(precisionIncrease);
+        const userSpotPosition = this.getUserAccount().spotPositions.find((spotPosition) => (0, types_1.isVariant)(spotPosition.balanceType, 'deposit') &&
+            spotPosition.marketIndex == marketIndex);
+        const userSpotBalance = userSpotPosition
+            ? (0, spotBalance_1.getTokenAmount)(userSpotPosition.scaledBalance, this.clearingHouse.getSpotMarketAccount(marketIndex), _1.SpotBalanceType.DEPOSIT)
+            : numericConstants_1.ZERO;
+        const maxWithdrawValue = _1.BN.min(_1.BN.min(amountWithdrawable, userSpotBalance), withdrawLimit.abs());
+        if (reduceOnly) {
+            return _1.BN.max(maxWithdrawValue, numericConstants_1.ZERO);
+        }
+        else {
+            const weightedAssetValue = this.getSpotMarketAssetValue(marketIndex, 'Initial', false);
+            const freeCollatAfterWithdraw = userSpotBalance.gt(numericConstants_1.ZERO)
+                ? freeCollateral.sub(weightedAssetValue)
+                : freeCollateral;
+            const maxLiabilityAllowed = freeCollatAfterWithdraw
+                .mul(numericConstants_1.MARGIN_PRECISION)
+                .div(spotMarket.initialLiabilityWeight)
+                .mul(numericConstants_1.PRICE_PRECISION)
+                .div(oracleData.price)
+                .mul(precisionIncrease);
+            const maxBorrowValue = _1.BN.min(maxWithdrawValue.add(maxLiabilityAllowed), borrowLimit.abs());
+            return _1.BN.max(maxBorrowValue, numericConstants_1.ZERO);
+        }
+    }
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore
      * @returns positionValue : Precision QUOTE_PRECISION
      */
-    getTotalPerpPositionValueExcludingMarket(marketToIgnore) {
+    getTotalPerpPositionValueExcludingMarket(marketToIgnore, marginCategory, liquidationBuffer, includeOpenOrders) {
         const currentPerpPosition = this.getUserPosition(marketToIgnore) ||
             this.getEmptyPosition(marketToIgnore);
-        const oracleData = this.getOracleDataForMarket(marketToIgnore);
+        const oracleData = this.getOracleDataForPerpMarket(marketToIgnore);
         let currentPerpPositionValueUSDC = numericConstants_1.ZERO;
         if (currentPerpPosition) {
             currentPerpPositionValueUSDC = this.getPerpPositionValue(marketToIgnore, oracleData);
         }
-        return this.getTotalPerpPositionValue().sub(currentPerpPositionValueUSDC);
+        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders).sub(currentPerpPositionValueUSDC);
     }
-    getOracleDataForMarket(marketIndex) {
+    getOracleDataForPerpMarket(marketIndex) {
         const oracleKey = this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;
         const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
         return oracleData;

package/lib/config.d.ts

@@ -6,6 +6,8 @@ declare type DriftConfig = {
     PYTH_ORACLE_MAPPING_ADDRESS: string;
     CLEARING_HOUSE_PROGRAM_ID: string;
     USDC_MINT_ADDRESS: string;
+    SERUM_V3: string;
+    V2_ALPHA_TICKET_MINT_ADDRESS: string;
     PERP_MARKETS: PerpMarketConfig[];
     SPOT_MARKETS: SpotMarketConfig[];
 };

package/lib/config.js

@@ -7,8 +7,10 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: 'DUZwKJKAk2C9S88BYvQzck1M1i5hySQjxB4zW6tJ29Nw',
+        CLEARING_HOUSE_PROGRAM_ID: 'FPVkWvcQgc4aCS8TrKo5c8GqTbKMauvzpADdqzRT2WbT',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
+        SERUM_V3: 'DESVgJVGajEgKGXhb6XmqDHGz3VjdgP7rEVESBgxmroY',
+        V2_ALPHA_TICKET_MINT_ADDRESS: 'DeEiGWfCMP9psnLGkxGrBBMEAW5Jv8bBGMN8DCtFRCyB',
         PERP_MARKETS: perpMarkets_1.DevnetPerpMarkets,
         SPOT_MARKETS: spotMarkets_1.DevnetSpotMarkets,
     },
@@ -17,6 +19,8 @@ exports.configs = {
         PYTH_ORACLE_MAPPING_ADDRESS: 'AHtgzX45WTKfkPG53L6WYhGEXwQkN1BVknET3sVsLL8J',
         CLEARING_HOUSE_PROGRAM_ID: 'dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN',
         USDC_MINT_ADDRESS: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+        SERUM_V3: '9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin',
+        V2_ALPHA_TICKET_MINT_ADDRESS: '',
         PERP_MARKETS: perpMarkets_1.MainnetMarkets,
         SPOT_MARKETS: spotMarkets_1.MainnetSpotMarkets,
     },

package/lib/constants/numericConstants.d.ts

@@ -25,6 +25,7 @@ export declare const SPOT_MARKET_RATE_PRECISION_EXP: BN;
 export declare const SPOT_MARKET_RATE_PRECISION: BN;
 export declare const SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP: BN;
 export declare const SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION: BN;
+export declare const SPOT_MARKET_UTILIZATION_PRECISION_EXP: BN;
 export declare const SPOT_MARKET_UTILIZATION_PRECISION: BN;
 export declare const SPOT_MARKET_WEIGHT_PRECISION: BN;
 export declare const SPOT_MARKET_BALANCE_PRECISION_EXP: BN;

package/lib/constants/numericConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LAMPORTS_EXP = exports.LAMPORTS_PRECISION = exports.QUOTE_SPOT_MARKET_INDEX = exports.ONE_YEAR = exports.BID_ASK_SPREAD_PRECISION = exports.MARGIN_PRECISION = exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.PRICE_TO_QUOTE_PRECISION = exports.PRICE_DIV_PEG = exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.BASE_PRECISION_EXP = exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION = exports.PEG_PRECISION = exports.FUNDING_RATE_BUFFER_PRECISION = exports.PRICE_PRECISION = exports.QUOTE_PRECISION = exports.LIQUIDATION_FEE_PRECISION = exports.SPOT_MARKET_IMF_PRECISION = exports.SPOT_MARKET_IMF_PRECISION_EXP = exports.SPOT_MARKET_BALANCE_PRECISION = exports.SPOT_MARKET_BALANCE_PRECISION_EXP = exports.SPOT_MARKET_WEIGHT_PRECISION = exports.SPOT_MARKET_UTILIZATION_PRECISION = exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION = exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP = exports.SPOT_MARKET_RATE_PRECISION = exports.SPOT_MARKET_RATE_PRECISION_EXP = exports.AMM_RESERVE_PRECISION_EXP = exports.PEG_PRECISION_EXP = exports.FUNDING_RATE_PRECISION_EXP = exports.PRICE_PRECISION_EXP = exports.FUNDING_RATE_BUFFER_PRECISION_EXP = exports.QUOTE_PRECISION_EXP = exports.MAX_LEVERAGE = exports.TEN_MILLION = exports.BN_MAX = exports.TEN_THOUSAND = exports.TEN = exports.NINE = exports.EIGHT = exports.SEVEN = exports.SIX = exports.FIVE = exports.FOUR = exports.THREE = exports.TWO = exports.ONE = exports.ZERO = void 0;
+exports.LAMPORTS_EXP = exports.LAMPORTS_PRECISION = exports.QUOTE_SPOT_MARKET_INDEX = exports.ONE_YEAR = exports.BID_ASK_SPREAD_PRECISION = exports.MARGIN_PRECISION = exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.PRICE_TO_QUOTE_PRECISION = exports.PRICE_DIV_PEG = exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.BASE_PRECISION_EXP = exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION = exports.PEG_PRECISION = exports.FUNDING_RATE_BUFFER_PRECISION = exports.PRICE_PRECISION = exports.QUOTE_PRECISION = exports.LIQUIDATION_FEE_PRECISION = exports.SPOT_MARKET_IMF_PRECISION = exports.SPOT_MARKET_IMF_PRECISION_EXP = exports.SPOT_MARKET_BALANCE_PRECISION = exports.SPOT_MARKET_BALANCE_PRECISION_EXP = exports.SPOT_MARKET_WEIGHT_PRECISION = exports.SPOT_MARKET_UTILIZATION_PRECISION = exports.SPOT_MARKET_UTILIZATION_PRECISION_EXP = exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION = exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP = exports.SPOT_MARKET_RATE_PRECISION = exports.SPOT_MARKET_RATE_PRECISION_EXP = exports.AMM_RESERVE_PRECISION_EXP = exports.PEG_PRECISION_EXP = exports.FUNDING_RATE_PRECISION_EXP = exports.PRICE_PRECISION_EXP = exports.FUNDING_RATE_BUFFER_PRECISION_EXP = exports.QUOTE_PRECISION_EXP = exports.MAX_LEVERAGE = exports.TEN_MILLION = exports.BN_MAX = exports.TEN_THOUSAND = exports.TEN = exports.NINE = exports.EIGHT = exports.SEVEN = exports.SIX = exports.FIVE = exports.FOUR = exports.THREE = exports.TWO = exports.ONE = exports.ZERO = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const __1 = require("../");
 exports.ZERO = new __1.BN(0);
@@ -28,7 +28,8 @@ exports.SPOT_MARKET_RATE_PRECISION_EXP = new __1.BN(6);
 exports.SPOT_MARKET_RATE_PRECISION = new __1.BN(10).pow(exports.SPOT_MARKET_RATE_PRECISION_EXP);
 exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP = new __1.BN(10);
 exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION = new __1.BN(10).pow(exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP);
-exports.SPOT_MARKET_UTILIZATION_PRECISION = new __1.BN(1000000);
+exports.SPOT_MARKET_UTILIZATION_PRECISION_EXP = new __1.BN(6);
+exports.SPOT_MARKET_UTILIZATION_PRECISION = new __1.BN(10).pow(exports.SPOT_MARKET_UTILIZATION_PRECISION_EXP);
 exports.SPOT_MARKET_WEIGHT_PRECISION = new __1.BN(10000);
 exports.SPOT_MARKET_BALANCE_PRECISION_EXP = new __1.BN(9);
 exports.SPOT_MARKET_BALANCE_PRECISION = new __1.BN(10).pow(exports.SPOT_MARKET_BALANCE_PRECISION_EXP);

package/lib/dlob/DLOB.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { NodeList } from './NodeList';
-import { MarketType, BN, ClearingHouse, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, UserMap, MarketTypeStr } from '..';
+import { MarketType, BN, ClearingHouse, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, UserMapInterface, MarketTypeStr, StateAccount } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, TriggerOrderNode } from '..';
 export declare type MarketNodeLists = {
@@ -33,42 +33,49 @@ declare type Side = 'ask' | 'bid' | 'both' | 'nocross';
 export declare class DLOB {
     openOrders: Map<MarketTypeStr, Set<string>>;
     orderLists: Map<MarketTypeStr, Map<number, MarketNodeLists>>;
+    stateAccount: StateAccount;
     marketIndexToAccount: Map<MarketTypeStr, Map<number, PerpMarketAccount | SpotMarketAccount>>;
+    userMap: UserMapInterface;
     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 userMap map of all users
      * @param silent set to true to prevent logging on inserts and removals
      */
-    constructor(perpMarkets: PerpMarketAccount[], spotMarkets: SpotMarketAccount[], silent?: boolean);
+    constructor(perpMarkets: PerpMarketAccount[], spotMarkets: SpotMarketAccount[], stateAccount: StateAccount, userMap: UserMapInterface, silent?: boolean);
     clear(): void;
     /**
      * 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>;
+    init(): Promise<boolean>;
     insertOrder(order: Order, userAccount: PublicKey, onInsert?: OrderBookCallback): void;
     trigger(order: Order, userAccount: PublicKey, onTrigger?: OrderBookCallback): void;
     getListForOrder(order: Order): NodeList<any> | undefined;
-    findNodesToFill(marketIndex: number, vBid: BN | undefined, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
     findCrossingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
-    findvAMMCrossingNodesToFill(marketIndex: number, vBid: BN, vAsk: BN, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
-    findExpiredMarketNodesToFill(marketIndex: number, slot: number, marketType: MarketType): NodeToFill[];
+    findFallbackCrossingNodesToFill(marketIndex: number, fallbackBid: BN, fallbackAsk: BN, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
     findJitAuctionNodesToFill(marketIndex: number, slot: number, marketType: MarketType): NodeToFill[];
     getMarketBids(marketIndex: number, marketType: MarketType): Generator<DLOBNode>;
     getMarketAsks(marketIndex: number, marketType: MarketType): Generator<DLOBNode>;
-    getAsks(marketIndex: number, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
-    getBids(marketIndex: number, vBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    getBids(marketIndex: number, fallbackBid: 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: number, vAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
-    getBestBid(marketIndex: number, vBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
+        takerNode: DLOBNode;
+        makerNode: DLOBNode;
+        makerSide: Side;
+    };
+    getBestAsk(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    getBestBid(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
     findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType): NodeToTrigger[];
     printTopOfOrderLists(sdkConfig: any, clearingHouse: ClearingHouse, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
 }