@drift-labs/sdk 2.15.0-beta.0 → 2.16.0-beta.0

package/lib/user.js

@@ -242,15 +242,15 @@ class User {
      * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION
      */
-    getBuyingPower(marketIndex) {
+    getPerpBuyingPower(marketIndex) {
         const perpPosition = this.getPerpPosition(marketIndex);
         const worstCaseBaseAssetAmount = perpPosition
             ? margin_1.calculateWorstCaseBaseAssetAmount(perpPosition)
             : numericConstants_1.ZERO;
         const freeCollateral = this.getFreeCollateral();
-        return this.getBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, worstCaseBaseAssetAmount);
+        return this.getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, worstCaseBaseAssetAmount);
     }
-    getBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, baseAssetAmount) {
+    getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, baseAssetAmount) {
         const marginRatio = _1.calculateMarketMarginRatio(this.driftClient.getPerpMarketAccount(marketIndex), baseAssetAmount, 'Initial');
         return freeCollateral.mul(numericConstants_1.MARGIN_PRECISION).div(new _1.BN(marginRatio));
     }
@@ -325,16 +325,23 @@ class User {
             return pnl.add(_1.calculatePositionFundingPNL(market, perpPosition));
         }, numericConstants_1.ZERO);
     }
-    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
+    getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
         now = now || new _1.BN(new Date().getTime() / 1000);
-        return this.getUserAccount().spotPositions.reduce((totalLiabilityValue, spotPosition) => {
+        let netQuoteValue = numericConstants_1.ZERO;
+        let totalAssetValue = numericConstants_1.ZERO;
+        let totalLiabilityValue = numericConstants_1.ZERO;
+        for (const spotPosition of this.getUserAccount().spotPositions) {
+            const countForBase = marketIndex === undefined || spotPosition.marketIndex === marketIndex;
+            const countForQuote = marketIndex === undefined ||
+                marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX ||
+                (includeOpenOrders && spotPosition.openOrders !== 0);
             if (spotPosition_1.isSpotPositionAvailable(spotPosition) ||
-                (marketIndex !== undefined &&
-                    spotPosition.marketIndex !== marketIndex)) {
-                return totalLiabilityValue;
+                (!countForBase && !countForQuote)) {
+                continue;
             }
             const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
-            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX &&
+                countForQuote) {
                 if (types_1.isVariant(spotPosition.balanceType, 'borrow')) {
                     const tokenAmount = spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
                     let weight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
@@ -344,31 +351,43 @@ class User {
                     const weightedTokenValue = tokenAmount
                         .mul(weight)
                         .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
-                    return totalLiabilityValue.add(weightedTokenValue);
+                    netQuoteValue = netQuoteValue.sub(weightedTokenValue);
+                    continue;
                 }
                 else {
-                    return totalLiabilityValue;
+                    const tokenAmount = spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
+                    netQuoteValue = netQuoteValue.add(tokenAmount);
+                    continue;
                 }
             }
             const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
-            if (!includeOpenOrders) {
+            if (!includeOpenOrders && countForBase) {
                 if (types_1.isVariant(spotPosition.balanceType, 'borrow')) {
                     const tokenAmount = spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
                     const liabilityValue = this.getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer, strict, now);
-                    return totalLiabilityValue.add(liabilityValue);
+                    totalLiabilityValue = totalLiabilityValue.add(liabilityValue);
+                    continue;
                 }
                 else {
-                    return totalLiabilityValue;
+                    const tokenAmount = spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
+                    const assetValue = this.getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict, now);
+                    totalAssetValue = totalAssetValue.add(assetValue);
+                    continue;
                 }
             }
             const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = spotPosition_1.getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, this.getOracleDataForSpotMarket(spotPosition.marketIndex));
-            let newTotalLiabilityValue = totalLiabilityValue;
-            if (worstCaseTokenAmount.lt(numericConstants_1.ZERO)) {
+            if (worstCaseTokenAmount.gt(numericConstants_1.ZERO) && countForBase) {
+                const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict, now);
+                totalAssetValue = totalAssetValue.add(baseAssetValue);
+            }
+            if (worstCaseTokenAmount.lt(numericConstants_1.ZERO) && countForBase) {
                 const baseLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount.abs(), oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer, strict, now);
-                newTotalLiabilityValue =
-                    newTotalLiabilityValue.add(baseLiabilityValue);
+                totalLiabilityValue = totalLiabilityValue.add(baseLiabilityValue);
             }
-            if (worstCaseQuoteTokenAmount.lt(numericConstants_1.ZERO)) {
+            if (worstCaseQuoteTokenAmount.gt(numericConstants_1.ZERO) && countForQuote) {
+                netQuoteValue = netQuoteValue.add(worstCaseQuoteTokenAmount);
+            }
+            if (worstCaseQuoteTokenAmount.lt(numericConstants_1.ZERO) && countForQuote) {
                 let weight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
                 if (marginCategory === 'Initial') {
                     weight = _1.BN.max(weight, new _1.BN(this.getUserAccount().maxMarginRatio));
@@ -377,12 +396,21 @@ class User {
                     .abs()
                     .mul(weight)
                     .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
-                newTotalLiabilityValue =
-                    newTotalLiabilityValue.add(weightedTokenValue);
+                netQuoteValue = netQuoteValue.sub(weightedTokenValue);
             }
-            newTotalLiabilityValue = newTotalLiabilityValue.add(new _1.BN(spotPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
-            return newTotalLiabilityValue;
-        }, numericConstants_1.ZERO);
+            totalLiabilityValue = totalLiabilityValue.add(new _1.BN(spotPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+        }
+        if (netQuoteValue.gt(numericConstants_1.ZERO)) {
+            totalAssetValue = totalAssetValue.add(netQuoteValue);
+        }
+        else {
+            totalLiabilityValue = totalLiabilityValue.add(netQuoteValue.abs());
+        }
+        return { totalAssetValue, totalLiabilityValue };
+    }
+    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
+        const { totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict, now);
+        return totalLiabilityValue;
     }
     getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer, strict = false, now) {
         let liabilityValue = null;
@@ -409,46 +437,8 @@ class User {
         return liabilityValue;
     }
     getSpotMarketAssetValue(marketIndex, marginCategory, includeOpenOrders, strict = false, now) {
-        now = now || new _1.BN(new Date().getTime() / 1000);
-        return this.getUserAccount().spotPositions.reduce((totalAssetValue, spotPosition) => {
-            if (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 spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
-            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
-                if (types_1.isVariant(spotPosition.balanceType, 'deposit')) {
-                    const tokenAmount = spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
-                    return totalAssetValue.add(tokenAmount);
-                }
-                else {
-                    return totalAssetValue;
-                }
-            }
-            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
-            if (!includeOpenOrders) {
-                if (types_1.isVariant(spotPosition.balanceType, 'deposit')) {
-                    const tokenAmount = spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType);
-                    const assetValue = this.getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict, now);
-                    return totalAssetValue.add(assetValue);
-                }
-                else {
-                    return totalAssetValue;
-                }
-            }
-            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = 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, strict, now);
-                newTotalAssetValue = newTotalAssetValue.add(baseAssetValue);
-            }
-            if (worstCaseQuoteTokenAmount.gt(numericConstants_1.ZERO)) {
-                newTotalAssetValue = newTotalAssetValue.add(worstCaseQuoteTokenAmount);
-            }
-            return newTotalAssetValue;
-        }, numericConstants_1.ZERO);
+        const { totalAssetValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, undefined, includeOpenOrders, strict, now);
+        return totalAssetValue;
     }
     getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict = false, now) {
         let assetValue = null;
@@ -466,8 +456,17 @@ class User {
         }
         return assetValue;
     }
+    getSpotTokenAmount(marketIndex) {
+        const spotPosition = this.getSpotPosition(marketIndex);
+        return spotBalance_1.getTokenAmount(spotPosition.scaledBalance, this.driftClient.getSpotMarketAccount(marketIndex), spotPosition.balanceType);
+    }
+    getSpotPositionValue(marketIndex, marginCategory, includeOpenOrders, strict = false, now) {
+        const { totalAssetValue, totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(marketIndex, marginCategory, undefined, includeOpenOrders, strict, now);
+        return totalAssetValue.sub(totalLiabilityValue);
+    }
     getNetSpotMarketValue(withWeightMarginCategory) {
-        return this.getSpotMarketAssetValue(undefined, withWeightMarginCategory).sub(this.getSpotMarketLiabilityValue(undefined, withWeightMarginCategory));
+        const { totalAssetValue, totalLiabilityValue } = this.getSpotMarketAssetAndLiabilityValue(undefined, withWeightMarginCategory);
+        return totalAssetValue.sub(totalLiabilityValue);
     }
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
@@ -625,16 +624,27 @@ class User {
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage() {
-        const totalPerpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
-        const totalSpotLiability = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true);
-        const totalLiabilityValue = totalPerpLiability.add(totalSpotLiability);
-        const totalAssetValue = this.getTotalAssetValue();
-        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+        // get leverage components
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
+        const totalAssetValue = spotAssetValue.add(perpPnl);
+        const netAssetValue = totalAssetValue.sub(spotLiabilityValue);
         if (netAssetValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
         return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(netAssetValue);
     }
+    getLeverageComponents() {
+        const perpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
+        const perpPnl = this.getUnrealizedPNL(true);
+        const { totalAssetValue: spotAssetValue, totalLiabilityValue: spotLiabilityValue, } = this.getSpotMarketAssetAndLiabilityValue(undefined, undefined, undefined, true);
+        return {
+            perpLiabilityValue: perpLiability,
+            perpPnl,
+            spotAssetValue,
+            spotLiabilityValue,
+        };
+    }
     getTotalLiabilityValue(marginCategory) {
         return this.getTotalPerpPositionValue(marginCategory, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, undefined, true));
     }
@@ -646,19 +656,16 @@ class User {
      * @params category {Initial, Maintenance}
      * @returns : Precision TEN_THOUSAND
      */
-    getMaxLeverage(marketIndex, category = 'Initial') {
-        const market = this.driftClient.getPerpMarketAccount(marketIndex);
-        const totalPerpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
-        const totalSpotLiability = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true);
-        const totalAssetValue = this.getTotalAssetValue();
-        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+    getMaxLeverageForPerp(perpMarketIndex, category = 'Initial') {
+        const market = this.driftClient.getPerpMarketAccount(perpMarketIndex);
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const totalAssetValue = spotAssetValue.add(perpPnl);
+        const netAssetValue = totalAssetValue.sub(spotLiabilityValue);
         if (netAssetValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
-        const totalLiabilityValue = totalPerpLiability.add(totalSpotLiability);
-        const marginRatio = _1.calculateMarketMarginRatio(market, 
-        // worstCaseBaseAssetAmount.abs(),
-        numericConstants_1.ZERO, // todo
+        const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
+        const marginRatio = _1.calculateMarketMarginRatio(market, numericConstants_1.ZERO, // todo
         category);
         const freeCollateral = this.getFreeCollateral();
         // how much more liabilities can be opened w remaining free collateral
@@ -671,18 +678,60 @@ class User {
             .div(netAssetValue);
     }
     /**
-     * calculates margin ratio: total collateral / |total position value|
+     * calculates max allowable leverage exceeding hitting requirement category
+     * @param spotMarketIndex
+     * @param direction
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMaxLeverageForSpot(spotMarketIndex, direction) {
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
+        const totalAssetValue = spotAssetValue.add(perpPnl);
+        const netAssetValue = totalAssetValue.sub(spotLiabilityValue);
+        if (netAssetValue.eq(numericConstants_1.ZERO)) {
+            return numericConstants_1.ZERO;
+        }
+        const currentQuoteAssetValue = this.getSpotMarketAssetValue(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        const currentQuoteLiabilityValue = this.getSpotMarketLiabilityValue(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        const currentQuoteValue = currentQuoteAssetValue.sub(currentQuoteLiabilityValue);
+        const currentSpotMarketAssetValue = this.getSpotMarketAssetValue(spotMarketIndex);
+        const currentSpotMarketLiabilityValue = this.getSpotMarketLiabilityValue(spotMarketIndex);
+        const currentSpotMarketNetValue = currentSpotMarketAssetValue.sub(currentSpotMarketLiabilityValue);
+        const tradeQuoteAmount = this.getMaxTradeSizeUSDCForSpot(spotMarketIndex, direction, currentQuoteAssetValue, currentSpotMarketNetValue);
+        let assetValueToAdd = numericConstants_1.ZERO;
+        let liabilityValueToAdd = numericConstants_1.ZERO;
+        const newQuoteNetValue = types_1.isVariant(direction, 'short')
+            ? currentQuoteValue.add(tradeQuoteAmount)
+            : currentQuoteValue.sub(tradeQuoteAmount);
+        const newQuoteAssetValue = _1.BN.max(newQuoteNetValue, numericConstants_1.ZERO);
+        const newQuoteLiabilityValue = _1.BN.min(newQuoteNetValue, numericConstants_1.ZERO).abs();
+        assetValueToAdd = assetValueToAdd.add(newQuoteAssetValue.sub(currentQuoteAssetValue));
+        liabilityValueToAdd = liabilityValueToAdd.add(newQuoteLiabilityValue.sub(currentQuoteLiabilityValue));
+        const newSpotMarketNetValue = types_1.isVariant(direction, 'long')
+            ? currentSpotMarketNetValue.add(tradeQuoteAmount)
+            : currentSpotMarketNetValue.sub(tradeQuoteAmount);
+        const newSpotMarketAssetValue = _1.BN.max(newSpotMarketNetValue, numericConstants_1.ZERO);
+        const newSpotMarketLiabilityValue = _1.BN.min(newSpotMarketNetValue, numericConstants_1.ZERO).abs();
+        assetValueToAdd = assetValueToAdd.add(newSpotMarketAssetValue.sub(currentSpotMarketAssetValue));
+        liabilityValueToAdd = liabilityValueToAdd.add(newSpotMarketLiabilityValue.sub(currentSpotMarketLiabilityValue));
+        const finalTotalAssetValue = totalAssetValue.add(assetValueToAdd);
+        const finalTotalSpotLiability = spotLiabilityValue.add(liabilityValueToAdd);
+        const finalTotalLiabilityValue = totalLiabilityValue.add(liabilityValueToAdd);
+        const finalNetAssetValue = finalTotalAssetValue.sub(finalTotalSpotLiability);
+        return finalTotalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(finalNetAssetValue);
+    }
+    /**
+     * calculates margin ratio: 1 / leverage
      * @returns : Precision TEN_THOUSAND
      */
-    getMarginRatio(marginCategory) {
-        const totalPerpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
-        const totalSpotLiability = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true);
-        const totalLiabilityValue = totalPerpLiability.add(totalSpotLiability);
+    getMarginRatio() {
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
+        const totalAssetValue = spotAssetValue.add(perpPnl);
         if (totalLiabilityValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.BN_MAX;
         }
-        const totalAssetValue = this.getTotalAssetValue(marginCategory);
-        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+        const netAssetValue = totalAssetValue.sub(spotLiabilityValue);
         return netAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
     }
     canBeLiquidated() {
@@ -728,7 +777,7 @@ class User {
      * @param marketIndex
      * @returns Precision : PRICE_PRECISION
      */
-    spotLiquidationPrice(marketIndex) {
+    spotLiquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO) {
         const currentSpotPosition = this.getSpotPosition(marketIndex);
         if (!currentSpotPosition) {
             return new _1.BN(-1);
@@ -737,7 +786,8 @@ class User {
         const maintenanceMarginRequirement = this.getMaintenanceMarginRequirement();
         const freeCollateral = _1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(maintenanceMarginRequirement));
         const market = this.driftClient.getSpotMarketAccount(marketIndex);
-        const signedTokenAmount = _1.getSignedTokenAmount(spotBalance_1.getTokenAmount(currentSpotPosition.scaledBalance, market, currentSpotPosition.balanceType), currentSpotPosition.balanceType);
+        let signedTokenAmount = _1.getSignedTokenAmount(spotBalance_1.getTokenAmount(currentSpotPosition.scaledBalance, market, currentSpotPosition.balanceType), currentSpotPosition.balanceType);
+        signedTokenAmount = signedTokenAmount.add(positionBaseSizeChange);
         if (signedTokenAmount.eq(numericConstants_1.ZERO)) {
             return new _1.BN(-1);
         }
@@ -894,7 +944,7 @@ class User {
      * @param tradeSide
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
-    getMaxTradeSizeUSDC(targetMarketIndex, tradeSide) {
+    getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide) {
         const currentPosition = this.getPerpPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
         const targetSide = types_1.isVariant(tradeSide, 'short') ? 'short' : 'long';
@@ -909,7 +959,7 @@ class User {
         const oppositeSizeValueUSDC = targetingSameSide
             ? numericConstants_1.ZERO
             : this.getPerpPositionValue(targetMarketIndex, oracleData);
-        let maxPositionSize = this.getBuyingPower(targetMarketIndex);
+        let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex);
         if (maxPositionSize.gte(numericConstants_1.ZERO)) {
             if (oppositeSizeValueUSDC.eq(numericConstants_1.ZERO)) {
                 // case 1 : Regular trade where current total position less than max, and no opposite position to account for
@@ -936,7 +986,7 @@ class User {
                 }
                 else {
                     const freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
-                    const buyingPowerAfterClose = this.getBuyingPowerFromFreeCollateralAndBaseAssetAmount(targetMarketIndex, freeCollateralAfterClose, numericConstants_1.ZERO);
+                    const buyingPowerAfterClose = this.getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(targetMarketIndex, freeCollateralAfterClose, numericConstants_1.ZERO);
                     maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
                 }
             }
@@ -949,15 +999,99 @@ class User {
         const oneMilli = maxPositionSize.div(numericConstants_1.QUOTE_PRECISION);
         return maxPositionSize.sub(oneMilli);
     }
+    /**
+     * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
+     *
+     * @param targetMarketIndex
+     * @param direction
+     * @param currentQuoteAssetValue
+     * @param currentSpotMarketNetValue
+     * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
+     */
+    getMaxTradeSizeUSDCForSpot(targetMarketIndex, direction, currentQuoteAssetValue, currentSpotMarketNetValue) {
+        const market = this.driftClient.getSpotMarketAccount(targetMarketIndex);
+        currentQuoteAssetValue = this.getSpotMarketAssetValue(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        currentSpotMarketNetValue =
+            currentSpotMarketNetValue !== null && currentSpotMarketNetValue !== void 0 ? currentSpotMarketNetValue : this.getSpotPositionValue(targetMarketIndex);
+        let freeCollateral = this.getFreeCollateral();
+        const marginRatio = _1.calculateSpotMarketMarginRatio(market, 'Initial', numericConstants_1.ZERO, types_1.isVariant(direction, 'long')
+            ? _1.SpotBalanceType.DEPOSIT
+            : _1.SpotBalanceType.BORROW);
+        let tradeAmount = numericConstants_1.ZERO;
+        if (this.getUserAccount().isMarginTradingEnabled) {
+            // if the user is buying/selling and already short/long, need to account for closing out short/long
+            if (types_1.isVariant(direction, 'long') && currentSpotMarketNetValue.lt(numericConstants_1.ZERO)) {
+                tradeAmount = currentSpotMarketNetValue.abs();
+                const marginRatio = _1.calculateSpotMarketMarginRatio(market, 'Initial', this.getSpotTokenAmount(targetMarketIndex), _1.SpotBalanceType.BORROW);
+                freeCollateral = freeCollateral.add(tradeAmount.mul(new _1.BN(marginRatio)).div(numericConstants_1.MARGIN_PRECISION));
+            }
+            else if (types_1.isVariant(direction, 'short') &&
+                currentSpotMarketNetValue.gt(numericConstants_1.ZERO)) {
+                tradeAmount = currentSpotMarketNetValue;
+                const marginRatio = _1.calculateSpotMarketMarginRatio(market, 'Initial', this.getSpotTokenAmount(targetMarketIndex), _1.SpotBalanceType.DEPOSIT);
+                freeCollateral = freeCollateral.add(tradeAmount.mul(new _1.BN(marginRatio)).div(numericConstants_1.MARGIN_PRECISION));
+            }
+            tradeAmount = tradeAmount.add(freeCollateral.mul(numericConstants_1.MARGIN_PRECISION).div(new _1.BN(marginRatio)));
+        }
+        else if (types_1.isVariant(direction, 'long')) {
+            tradeAmount = _1.BN.min(currentQuoteAssetValue, freeCollateral.mul(numericConstants_1.MARGIN_PRECISION).div(new _1.BN(marginRatio)));
+        }
+        else {
+            tradeAmount = _1.BN.max(numericConstants_1.ZERO, currentSpotMarketNetValue);
+        }
+        return tradeAmount;
+    }
     // TODO - should this take the price impact of the trade into account for strict accuracy?
     /**
      * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
      * @param targetMarketIndex
-     * @param positionMarketIndex
+     * @param: targetMarketType
      * @param tradeQuoteAmount
+     * @param tradeSide
+     * @param includeOpenOrders
      * @returns leverageRatio : Precision TEN_THOUSAND
      */
-    accountLeverageRatioAfterTrade(targetMarketIndex, tradeQuoteAmount, tradeSide, includeOpenOrders = true) {
+    accountLeverageRatioAfterTrade(targetMarketIndex, targetMarketType, tradeQuoteAmount, tradeSide, includeOpenOrders = true) {
+        const tradeIsPerp = types_1.isVariant(targetMarketType, 'perp');
+        if (!tradeIsPerp) {
+            // calculate new asset/liability values for base and quote market to find new account leverage
+            const totalLiabilityValue = this.getTotalLiabilityValue();
+            const totalAssetValue = this.getTotalAssetValue();
+            const spotLiabilityValue = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, includeOpenOrders);
+            const currentQuoteAssetValue = this.getSpotMarketAssetValue(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, undefined, includeOpenOrders);
+            const currentQuoteLiabilityValue = this.getSpotMarketLiabilityValue(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, undefined, undefined, includeOpenOrders);
+            const currentQuoteValue = currentQuoteAssetValue.sub(currentQuoteLiabilityValue);
+            const currentSpotMarketAssetValue = this.getSpotMarketAssetValue(targetMarketIndex, undefined, includeOpenOrders);
+            const currentSpotMarketLiabilityValue = this.getSpotMarketLiabilityValue(targetMarketIndex, undefined, undefined, includeOpenOrders);
+            const currentSpotMarketNetValue = currentSpotMarketAssetValue.sub(currentSpotMarketLiabilityValue);
+            let assetValueToAdd = numericConstants_1.ZERO;
+            let liabilityValueToAdd = numericConstants_1.ZERO;
+            const newQuoteNetValue = tradeSide == _1.PositionDirection.SHORT
+                ? currentQuoteValue.add(tradeQuoteAmount)
+                : currentQuoteValue.sub(tradeQuoteAmount);
+            const newQuoteAssetValue = _1.BN.max(newQuoteNetValue, numericConstants_1.ZERO);
+            const newQuoteLiabilityValue = _1.BN.min(newQuoteNetValue, numericConstants_1.ZERO).abs();
+            assetValueToAdd = assetValueToAdd.add(newQuoteAssetValue.sub(currentQuoteAssetValue));
+            liabilityValueToAdd = liabilityValueToAdd.add(newQuoteLiabilityValue.sub(currentQuoteLiabilityValue));
+            const newSpotMarketNetValue = tradeSide == _1.PositionDirection.LONG
+                ? currentSpotMarketNetValue.add(tradeQuoteAmount)
+                : currentSpotMarketNetValue.sub(tradeQuoteAmount);
+            const newSpotMarketAssetValue = _1.BN.max(newSpotMarketNetValue, numericConstants_1.ZERO);
+            const newSpotMarketLiabilityValue = _1.BN.min(newSpotMarketNetValue, numericConstants_1.ZERO).abs();
+            assetValueToAdd = assetValueToAdd.add(newSpotMarketAssetValue.sub(currentSpotMarketAssetValue));
+            liabilityValueToAdd = liabilityValueToAdd.add(newSpotMarketLiabilityValue.sub(currentSpotMarketLiabilityValue));
+            const totalAssetValueAfterTrade = totalAssetValue.add(assetValueToAdd);
+            const totalSpotLiabilityValueAfterTrade = spotLiabilityValue.add(liabilityValueToAdd);
+            const totalLiabilityValueAfterTrade = totalLiabilityValue.add(liabilityValueToAdd);
+            const netAssetValueAfterTrade = totalAssetValueAfterTrade.sub(totalSpotLiabilityValueAfterTrade);
+            if (netAssetValueAfterTrade.eq(numericConstants_1.ZERO)) {
+                return numericConstants_1.ZERO;
+            }
+            const newLeverage = totalLiabilityValueAfterTrade
+                .mul(numericConstants_1.TEN_THOUSAND)
+                .div(netAssetValueAfterTrade);
+            return newLeverage;
+        }
         const currentPosition = this.getPerpPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
         const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
@@ -1063,7 +1197,7 @@ class User {
                 depositAmount: numericConstants_1.ZERO,
             };
         }
-        const depositAmount = spotBalance_1.getTokenAmount(position.scaledBalance, spotMarket, 'deposit');
+        const depositAmount = spotBalance_1.getTokenAmount(position.scaledBalance, spotMarket, _1.SpotBalanceType.DEPOSIT);
         if (netDeposits.lt(numericConstants_1.ZERO)) {
             return {
                 canBypass: false,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.15.0-beta.0",
+	"version": "2.16.0-beta.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/constants/perpMarkets.ts

@@ -87,6 +87,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1670347281000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'Aptos',
+		category: ['L1', 'Infra'],
+		symbol: 'APT-PERP',
+		baseAssetSymbol: 'APT',
+		marketIndex: 3,
+		oracle: new PublicKey('FNNvb1AFDnDVPkocEri8mWbJ1952HQZtFLuwPiUjSJQ'),
+		launchTs: 1675802661000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/events/fetchLogs.ts

@@ -61,15 +61,15 @@ export async function fetchLogs(
 
 	const chunkedSignatures = chunk(filteredSignatures, 100);
 
+	const config = { commitment: finality, maxSupportedTransactionVersion: 0 };
+
 	const transactionLogs = (
 		await Promise.all(
 			chunkedSignatures.map(async (chunk) => {
 				const transactions = await connection.getTransactions(
 					chunk.map((confirmedSignature) => confirmedSignature.signature),
-					{
-						commitment: finality,
-						maxSupportedTransactionVersion: 0,
-					}
+					//@ts-ignore
+					config
 				);
 
 				return transactions.reduce((logs, transaction) => {

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.15.0-0",
+  "version": "2.16.0-beta.0",
   "name": "drift",
   "instructions": [
     {

package/src/math/market.ts

@@ -25,9 +25,11 @@ import {
 	MARGIN_PRECISION,
 	PRICE_TO_QUOTE_PRECISION,
 	ZERO,
+	QUOTE_SPOT_MARKET_INDEX,
 } from '../constants/numericConstants';
 import { getTokenAmount } from './spotBalance';
 import { DLOB } from '../dlob/DLOB';
+import { assert } from '../assert/assert';
 
 /**
  * Calculates market mark price
@@ -131,7 +133,7 @@ export function calculateMarketMarginRatio(
 ): number {
 	let marginRatio;
 	switch (marginCategory) {
-		case 'Initial':
+		case 'Initial': {
 			marginRatio = calculateSizePremiumLiabilityWeight(
 				size,
 				new BN(market.imfFactor),
@@ -139,7 +141,8 @@ export function calculateMarketMarginRatio(
 				MARGIN_PRECISION
 			).toNumber();
 			break;
-		case 'Maintenance':
+		}
+		case 'Maintenance': {
 			marginRatio = calculateSizePremiumLiabilityWeight(
 				size,
 				new BN(market.imfFactor),
@@ -147,6 +150,7 @@ export function calculateMarketMarginRatio(
 				MARGIN_PRECISION
 			).toNumber();
 			break;
+		}
 	}
 
 	return marginRatio;
@@ -202,6 +206,25 @@ export function calculateMarketAvailablePNL(
 	);
 }
 
+export function calculateMarketMaxAvailableInsurance(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount
+): BN {
+	assert(spotMarket.marketIndex == QUOTE_SPOT_MARKET_INDEX);
+
+	// todo: insuranceFundAllocation technically not guaranteed to be in Insurance Fund
+	const insuranceFundAllocation =
+		perpMarket.insuranceClaim.quoteMaxInsurance.sub(
+			perpMarket.insuranceClaim.quoteSettledInsurance
+		);
+	const ammFeePool = getTokenAmount(
+		perpMarket.amm.feePool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	return insuranceFundAllocation.add(ammFeePool);
+}
+
 export function calculateNetUserPnl(
 	perpMarket: PerpMarketAccount,
 	oraclePriceData: OraclePriceData

package/src/math/spotBalance.ts

@@ -146,27 +146,27 @@ export function calculateAssetWeight(
 }
 
 export function calculateLiabilityWeight(
-	balanceAmount: BN,
+	size: BN,
 	spotMarket: SpotMarketAccount,
 	marginCategory: MarginCategory
 ): BN {
 	const sizePrecision = TEN.pow(new BN(spotMarket.decimals));
 	let sizeInAmmReservePrecision;
 	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
-		sizeInAmmReservePrecision = balanceAmount.div(
+		sizeInAmmReservePrecision = size.div(
 			sizePrecision.div(AMM_RESERVE_PRECISION)
 		);
 	} else {
-		sizeInAmmReservePrecision = balanceAmount
+		sizeInAmmReservePrecision = size
 			.mul(AMM_RESERVE_PRECISION)
 			.div(sizePrecision);
 	}
 
-	let assetWeight;
+	let liabilityWeight;
 
 	switch (marginCategory) {
 		case 'Initial':
-			assetWeight = calculateSizePremiumLiabilityWeight(
+			liabilityWeight = calculateSizePremiumLiabilityWeight(
 				sizeInAmmReservePrecision,
 				new BN(spotMarket.imfFactor),
 				new BN(spotMarket.initialLiabilityWeight),
@@ -174,7 +174,7 @@ export function calculateLiabilityWeight(
 			);
 			break;
 		case 'Maintenance':
-			assetWeight = calculateSizePremiumLiabilityWeight(
+			liabilityWeight = calculateSizePremiumLiabilityWeight(
 				sizeInAmmReservePrecision,
 				new BN(spotMarket.imfFactor),
 				new BN(spotMarket.maintenanceLiabilityWeight),
@@ -182,11 +182,11 @@ export function calculateLiabilityWeight(
 			);
 			break;
 		default:
-			assetWeight = spotMarket.initialLiabilityWeight;
+			liabilityWeight = spotMarket.initialLiabilityWeight;
 			break;
 	}
 
-	return assetWeight;
+	return liabilityWeight;
 }
 
 export function calculateUtilization(bank: SpotMarketAccount): BN {