@drift-labs/sdk 2.13.0-beta.0 → 2.13.0-beta.2

package/lib/user.js

@@ -11,6 +11,7 @@ const margin_1 = require("./math/margin");
 const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
 const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
 const spotPosition_1 = require("./math/spotPosition");
+const oracles_1 = require("./math/oracles");
 class User {
     constructor(config) {
         var _a;
@@ -238,13 +239,20 @@ class User {
         return [position, remainderBaa, pnl];
     }
     /**
-     * calculates Buying Power = FC * MAX_LEVERAGE
+     * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION
      */
     getBuyingPower(marketIndex) {
-        return this.getFreeCollateral()
-            .mul(this.getMaxLeverage(marketIndex, 'Initial'))
-            .div(numericConstants_1.TEN_THOUSAND);
+        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);
+    }
+    getBuyingPowerFromFreeCollateralAndBaseAssetAmount(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));
     }
     /**
      * calculates Free Collateral = Total collateral - initial margin requirement
@@ -259,14 +267,14 @@ class User {
     /**
      * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
      */
-    getMarginRequirement(marginCategory, liquidationBuffer) {
-        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, liquidationBuffer, true));
+    getMarginRequirement(marginCategory, liquidationBuffer, strict = false) {
+        return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, liquidationBuffer, true, strict));
     }
     /**
      * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
      */
     getInitialMarginRequirement() {
-        return this.getMarginRequirement('Initial');
+        return this.getMarginRequirement('Initial', undefined, true);
     }
     /**
      * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
@@ -317,7 +325,8 @@ class User {
             return pnl.add(_1.calculatePositionFundingPNL(market, perpPosition));
         }, numericConstants_1.ZERO);
     }
-    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders) {
+    getSpotMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false, now) {
+        now = now || new _1.BN(new Date().getTime() / 1000);
         return this.getUserAccount().spotPositions.reduce((totalLiabilityValue, spotPosition) => {
             if (spotPosition_1.isSpotPositionAvailable(spotPosition) ||
                 (marketIndex !== undefined &&
@@ -345,7 +354,7 @@ class User {
             if (!includeOpenOrders) {
                 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);
+                    const liabilityValue = this.getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer, strict, now);
                     return totalLiabilityValue.add(liabilityValue);
                 }
                 else {
@@ -355,7 +364,7 @@ class User {
             const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = spotPosition_1.getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, this.getOracleDataForSpotMarket(spotPosition.marketIndex));
             let newTotalLiabilityValue = totalLiabilityValue;
             if (worstCaseTokenAmount.lt(numericConstants_1.ZERO)) {
-                const baseLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount.abs(), oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer);
+                const baseLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount.abs(), oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer, strict, now);
                 newTotalLiabilityValue =
                     newTotalLiabilityValue.add(baseLiabilityValue);
             }
@@ -375,8 +384,16 @@ class User {
             return newTotalLiabilityValue;
         }, numericConstants_1.ZERO);
     }
-    getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer) {
-        let liabilityValue = _1.getTokenValue(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+    getSpotLiabilityValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, liquidationBuffer, strict = false, now) {
+        let liabilityValue = null;
+        if (strict && spotMarketAccount.marketIndex != numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+            const estOracleTwap = oracles_1.calculateLiveOracleTwap(spotMarketAccount.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE // 5MIN
+            );
+            liabilityValue = _1.getStrictTokenValue(tokenAmount, spotMarketAccount.decimals, oraclePriceData, estOracleTwap);
+        }
+        else {
+            liabilityValue = _1.getTokenValue(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+        }
         if (marginCategory !== undefined) {
             let weight = spotBalance_1.calculateLiabilityWeight(tokenAmount, spotMarketAccount, marginCategory);
             if (marginCategory === 'Initial') {
@@ -391,7 +408,8 @@ class User {
         }
         return liabilityValue;
     }
-    getSpotMarketAssetValue(marketIndex, marginCategory, includeOpenOrders) {
+    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 &&
@@ -413,7 +431,7 @@ class User {
             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);
+                    const assetValue = this.getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict, now);
                     return totalAssetValue.add(assetValue);
                 }
                 else {
@@ -423,7 +441,7 @@ class User {
             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);
+                const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict, now);
                 newTotalAssetValue = newTotalAssetValue.add(baseAssetValue);
             }
             if (worstCaseQuoteTokenAmount.gt(numericConstants_1.ZERO)) {
@@ -432,8 +450,16 @@ class User {
             return newTotalAssetValue;
         }, numericConstants_1.ZERO);
     }
-    getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory) {
-        let assetValue = _1.getTokenValue(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+    getSpotAssetValue(tokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict = false, now) {
+        let assetValue = null;
+        if (strict && spotMarketAccount.marketIndex != numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+            const estOracleTwap = oracles_1.calculateLiveOracleTwap(spotMarketAccount.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE // 5MIN
+            );
+            assetValue = _1.getStrictTokenValue(tokenAmount, spotMarketAccount.decimals, oraclePriceData, estOracleTwap);
+        }
+        else {
+            assetValue = _1.getTokenValue(tokenAmount, spotMarketAccount.decimals, oraclePriceData);
+        }
         if (marginCategory !== undefined) {
             const weight = spotBalance_1.calculateAssetWeight(tokenAmount, spotMarketAccount, marginCategory);
             assetValue = assetValue.mul(weight).div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
@@ -470,12 +496,8 @@ class User {
             health = 0;
         }
         else {
-            // const totalCollateral = this.getTotalCollateral('Initial');
-            // const maintenanceMarginReq = this.getMaintenanceMarginRequirement();
-            const marginRatio = this.getMarginRatio().toNumber() / numericConstants_1.MARGIN_PRECISION.toNumber();
-            const maintenanceRatio = (maintenanceMarginReq.toNumber() / totalCollateral.toNumber()) *
-                marginRatio;
-            const healthP1 = Math.max(0, (marginRatio - maintenanceRatio) * 100) + 1;
+            const healthP1 = Math.max(0, (1 - maintenanceMarginReq.toNumber() / totalCollateral.toNumber()) *
+                100) + 1;
             health = Math.min(1, Math.log(healthP1) / Math.log(100)) * 100;
             if (health > 1) {
                 health = Math.round(health);
@@ -542,10 +564,10 @@ class User {
      * calculates position value in margin system
      * @returns : Precision QUOTE_PRECISION
      */
-    getPerpPositionValue(marketIndex, oraclePriceData) {
+    getPerpPositionValue(marketIndex, oraclePriceData, includeOpenOrders = false) {
         const userPosition = this.getPerpPosition(marketIndex) || this.getEmptyPosition(marketIndex);
         const market = this.driftClient.getPerpMarketAccount(userPosition.marketIndex);
-        return margin_1.calculateBaseAssetValueWithOracle(market, userPosition, oraclePriceData);
+        return margin_1.calculateBaseAssetValueWithOracle(market, userPosition, oraclePriceData, includeOpenOrders);
     }
     getPositionSide(currentPosition) {
         if (currentPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
@@ -599,16 +621,19 @@ class User {
         return [exitPrice, pnl];
     }
     /**
-     * calculates current user leverage across all positions
+     * calculates current user leverage which is (total liability size) / (net asset value)
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage() {
-        const totalLiabilityValue = this.getTotalLiabilityValue();
+        const totalPerpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
+        const totalSpotLiability = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true);
+        const totalLiabilityValue = totalPerpLiability.add(totalSpotLiability);
         const totalAssetValue = this.getTotalAssetValue();
-        if (totalAssetValue.eq(numericConstants_1.ZERO) && totalLiabilityValue.eq(numericConstants_1.ZERO)) {
+        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+        if (netAssetValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
-        return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(totalAssetValue);
+        return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(netAssetValue);
     }
     getTotalLiabilityValue(marginCategory) {
         return this.getTotalPerpPositionValue(marginCategory, undefined, true).add(this.getSpotMarketLiabilityValue(undefined, marginCategory, undefined, true));
@@ -623,11 +648,14 @@ class User {
      */
     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();
-        if (totalAssetValue.eq(numericConstants_1.ZERO)) {
+        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+        if (netAssetValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
-        const totalLiabilityValue = this.getTotalLiabilityValue();
+        const totalLiabilityValue = totalPerpLiability.add(totalSpotLiability);
         const marginRatio = _1.calculateMarketMarginRatio(market, 
         // worstCaseBaseAssetAmount.abs(),
         numericConstants_1.ZERO, // todo
@@ -640,19 +668,22 @@ class User {
         return totalLiabilityValue
             .add(additionalLiabilities)
             .mul(numericConstants_1.TEN_THOUSAND)
-            .div(totalAssetValue);
+            .div(netAssetValue);
     }
     /**
      * calculates margin ratio: total collateral / |total position value|
      * @returns : Precision TEN_THOUSAND
      */
     getMarginRatio(marginCategory) {
-        const totalLiabilityValue = this.getTotalLiabilityValue(marginCategory);
+        const totalPerpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
+        const totalSpotLiability = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true);
+        const totalLiabilityValue = totalPerpLiability.add(totalSpotLiability);
         if (totalLiabilityValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.BN_MAX;
         }
         const totalAssetValue = this.getTotalAssetValue(marginCategory);
-        return totalAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
+        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+        return netAssetValue.mul(numericConstants_1.TEN_THOUSAND).div(totalLiabilityValue);
     }
     canBeLiquidated() {
         const totalCollateral = this.getTotalCollateral('Maintenance');
@@ -753,9 +784,9 @@ class User {
 
         for 10x long, BTC down $400:
         3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
-        const totalCollateral = this.getTotalCollateral();
+        const totalCollateral = this.getTotalCollateral('Maintenance');
         // calculate the total position value ignoring any value from the target market of the trade
-        const totalPositionValueExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(perpPosition.marketIndex);
+        const totalPositionValueExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(perpPosition.marketIndex, undefined, undefined, true);
         const currentPerpPosition = this.getPerpPosition(perpPosition.marketIndex) ||
             this.getEmptyPosition(perpPosition.marketIndex);
         const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
@@ -765,13 +796,13 @@ class User {
             marketIndex: perpPosition.marketIndex,
             baseAssetAmount: proposedBaseAssetAmount,
             remainderBaseAssetAmount: 0,
-            quoteAssetAmount: new _1.BN(0),
+            quoteAssetAmount: currentPerpPosition.quoteAssetAmount,
             lastCumulativeFundingRate: numericConstants_1.ZERO,
             quoteBreakEvenAmount: new _1.BN(0),
             quoteEntryAmount: new _1.BN(0),
             openOrders: 0,
-            openBids: new _1.BN(0),
-            openAsks: new _1.BN(0),
+            openBids: currentPerpPosition.openBids,
+            openAsks: currentPerpPosition.openAsks,
             settledPnl: numericConstants_1.ZERO,
             lpShares: numericConstants_1.ZERO,
             lastBaseAssetAmountPerLp: numericConstants_1.ZERO,
@@ -780,62 +811,52 @@ class User {
         if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
             return new _1.BN(-1);
         const market = this.driftClient.getPerpMarketAccount(proposedPerpPosition.marketIndex);
-        const proposedPerpPositionValue = margin_1.calculateBaseAssetValueWithOracle(market, proposedPerpPosition, this.getOracleDataForPerpMarket(market.marketIndex));
+        const proposedPerpPositionValue = margin_1.calculateBaseAssetValueWithOracle(market, proposedPerpPosition, this.getOracleDataForPerpMarket(market.marketIndex), true);
         // 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.driftClient.getPerpMarketAccount(position.marketIndex);
-                const positionValue = margin_1.calculateBaseAssetValueWithOracle(market, position, this.getOracleDataForPerpMarket(market.marketIndex));
-                const marketMarginRequirement = positionValue
-                    .mul(new _1.BN(_1.calculateMarketMarginRatio(market, position.baseAssetAmount.abs(), 'Maintenance')))
-                    .div(numericConstants_1.MARGIN_PRECISION);
-                totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
-            }
-            return totalMarginRequirement;
-        }, numericConstants_1.ZERO);
+        const marginRequirementOfAll = this.getMaintenanceMarginRequirement();
+        const positionValue = margin_1.calculateBaseAssetValueWithOracle(market, currentPerpPosition, this.getOracleDataForPerpMarket(market.marketIndex), true);
+        const marginRequirementOfTargetMarket = positionValue
+            .mul(new _1.BN(_1.calculateMarketMarginRatio(market, margin_1.calculateWorstCaseBaseAssetAmount(currentPerpPosition).abs(), 'Maintenance')))
+            .div(numericConstants_1.MARGIN_PRECISION);
+        const marginRequirementExcludingTargetMarket = marginRequirementOfAll.sub(marginRequirementOfTargetMarket);
         const freeCollateralExcludingTargetMarket = totalCollateral.sub(marginRequirementExcludingTargetMarket);
         // if the position value after the trade is less than free collateral, there is no liq price
         if (totalPositionValueAfterTrade.lte(freeCollateralExcludingTargetMarket) &&
             proposedPerpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
             return new _1.BN(-1);
         }
-        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedPerpPositionValue
-            .mul(new _1.BN(_1.calculateMarketMarginRatio(market, proposedPerpPosition.baseAssetAmount.abs(), 'Maintenance')))
-            .div(numericConstants_1.MARGIN_PRECISION));
+        const proposedWorstCastBaseAssetAmount = margin_1.calculateWorstCaseBaseAssetAmount(proposedPerpPosition);
+        const marginRequirementTargetMarket = proposedPerpPositionValue
+            .mul(new _1.BN(_1.calculateMarketMarginRatio(market, proposedWorstCastBaseAssetAmount.abs(), 'Maintenance')))
+            .div(numericConstants_1.MARGIN_PRECISION);
+        const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(marginRequirementTargetMarket);
         const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
-        const marketMaxLeverage = this.getMaxLeverage(proposedPerpPosition.marketIndex, 'Maintenance');
+        const marketMaxMaintLeverage = new _1.BN(numericConstants_1.TEN_THOUSAND.mul(numericConstants_1.TEN_THOUSAND).toNumber() /
+            _1.calculateMarketMarginRatio(market, proposedWorstCastBaseAssetAmount.abs(), 'Maintenance'));
         let priceDelta;
         if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
             priceDelta = freeCollateralAfterTrade
-                .mul(marketMaxLeverage) // precision is TEN_THOUSAND
-                .div(marketMaxLeverage.add(numericConstants_1.TEN_THOUSAND))
+                .mul(marketMaxMaintLeverage) // precision is TEN_THOUSAND
+                .div(marketMaxMaintLeverage.add(numericConstants_1.TEN_THOUSAND))
                 .mul(numericConstants_1.PRICE_TO_QUOTE_PRECISION)
                 .mul(numericConstants_1.AMM_RESERVE_PRECISION)
                 .div(proposedBaseAssetAmount);
         }
         else {
             priceDelta = freeCollateralAfterTrade
-                .mul(marketMaxLeverage) // precision is TEN_THOUSAND
-                .div(marketMaxLeverage.sub(numericConstants_1.TEN_THOUSAND))
+                .mul(marketMaxMaintLeverage) // precision is TEN_THOUSAND
+                .div(marketMaxMaintLeverage.sub(numericConstants_1.TEN_THOUSAND))
                 .mul(numericConstants_1.PRICE_TO_QUOTE_PRECISION)
                 .mul(numericConstants_1.AMM_RESERVE_PRECISION)
                 .div(proposedBaseAssetAmount);
         }
-        let markPriceAfterTrade;
-        if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
-            markPriceAfterTrade = _1.calculateReservePrice(this.driftClient.getPerpMarketAccount(perpPosition.marketIndex), this.getOracleDataForPerpMarket(perpPosition.marketIndex));
-        }
-        else {
-            const direction = positionBaseSizeChange.gt(numericConstants_1.ZERO)
-                ? _1.PositionDirection.LONG
-                : _1.PositionDirection.SHORT;
-            markPriceAfterTrade = _1.calculateTradeSlippage(direction, positionBaseSizeChange.abs(), this.driftClient.getPerpMarketAccount(perpPosition.marketIndex), 'base', this.getOracleDataForPerpMarket(perpPosition.marketIndex))[3]; // newPrice after swap
-        }
-        if (priceDelta.gt(markPriceAfterTrade)) {
+        const currentPrice = this.getOracleDataForPerpMarket(perpPosition.marketIndex).price;
+        if (priceDelta.gt(currentPrice) &&
+            proposedPerpPosition.baseAssetAmount.gte(numericConstants_1.ZERO)) {
             return new _1.BN(-1);
         }
-        return markPriceAfterTrade.sub(priceDelta);
+        return currentPrice.sub(priceDelta);
     }
     /**
      * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
@@ -920,9 +941,7 @@ class User {
                 }
                 else {
                     const freeCollateralAfterClose = totalCollateral.sub(marginRequirementAfterClosing);
-                    const buyingPowerAfterClose = freeCollateralAfterClose
-                        .mul(this.getMaxLeverage(targetMarketIndex))
-                        .div(numericConstants_1.TEN_THOUSAND);
+                    const buyingPowerAfterClose = this.getBuyingPowerFromFreeCollateralAndBaseAssetAmount(targetMarketIndex, freeCollateralAfterClose, numericConstants_1.ZERO);
                     maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
                 }
             }
@@ -947,7 +966,7 @@ class User {
         const currentPosition = this.getPerpPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
         const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
-        let currentPositionQuoteAmount = this.getPerpPositionValue(targetMarketIndex, oracleData);
+        let currentPositionQuoteAmount = this.getPerpPositionValue(targetMarketIndex, oracleData, includeOpenOrders);
         const currentSide = currentPosition && currentPosition.baseAssetAmount.isNeg()
             ? _1.PositionDirection.SHORT
             : _1.PositionDirection.LONG;
@@ -960,16 +979,18 @@ class User {
             .abs();
         const totalPositionAfterTradeExcludingTargetMarket = this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex, undefined, undefined, includeOpenOrders);
         const totalAssetValue = this.getTotalAssetValue();
-        const totalPerpPositionValue = currentPerpPositionAfterTrade
+        const totalPerpPositionLiability = 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)) {
+        const totalSpotLiability = this.getSpotMarketLiabilityValue(undefined, undefined, undefined, includeOpenOrders);
+        const totalLiabilitiesAfterTrade = totalPerpPositionLiability.add(totalSpotLiability);
+        const netAssetValue = totalAssetValue.sub(totalSpotLiability);
+        if (netAssetValue.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
         const newLeverage = totalLiabilitiesAfterTrade
             .mul(numericConstants_1.TEN_THOUSAND)
-            .div(totalAssetValue);
+            .div(netAssetValue);
         return newLeverage;
     }
     /**
@@ -992,28 +1013,28 @@ class User {
     getWithdrawalLimit(marketIndex, reduceOnly) {
         const nowTs = new _1.BN(Math.floor(Date.now() / 1000));
         const spotMarket = this.driftClient.getSpotMarketAccount(marketIndex);
-        const { borrowLimit, withdrawLimit } = spotBalance_1.calculateWithdrawLimit(spotMarket, nowTs);
+        // eslint-disable-next-line prefer-const
+        let { borrowLimit, withdrawLimit } = 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 { canBypass, depositAmount: userDepositAmount } = this.canBypassWithdrawLimits(marketIndex);
+        if (canBypass) {
+            withdrawLimit = _1.BN.max(withdrawLimit, userDepositAmount);
+        }
         const amountWithdrawable = freeCollateral
             .mul(numericConstants_1.MARGIN_PRECISION)
             .div(new _1.BN(spotMarket.initialAssetWeight))
             .mul(numericConstants_1.PRICE_PRECISION)
             .div(oracleData.price)
             .mul(precisionIncrease);
-        const userSpotPosition = this.getUserAccount().spotPositions.find((spotPosition) => types_1.isVariant(spotPosition.balanceType, 'deposit') &&
-            spotPosition.marketIndex == marketIndex);
-        const userSpotBalance = userSpotPosition
-            ? spotBalance_1.getTokenAmount(userSpotPosition.scaledBalance, this.driftClient.getSpotMarketAccount(marketIndex), _1.SpotBalanceType.DEPOSIT)
-            : numericConstants_1.ZERO;
-        const maxWithdrawValue = _1.BN.min(_1.BN.min(amountWithdrawable, userSpotBalance), withdrawLimit.abs());
+        const maxWithdrawValue = _1.BN.min(_1.BN.min(amountWithdrawable, userDepositAmount), 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)
+            const freeCollatAfterWithdraw = userDepositAmount.gt(numericConstants_1.ZERO)
                 ? freeCollateral.sub(weightedAssetValue)
                 : freeCollateral;
             const maxLiabilityAllowed = freeCollatAfterWithdraw
@@ -1026,6 +1047,43 @@ class User {
             return _1.BN.max(maxBorrowValue, numericConstants_1.ZERO);
         }
     }
+    canBypassWithdrawLimits(marketIndex) {
+        const spotMarket = this.driftClient.getSpotMarketAccount(marketIndex);
+        const maxDepositAmount = spotMarket.withdrawGuardThreshold.div(new _1.BN(10));
+        const position = this.getSpotPosition(marketIndex);
+        const netDeposits = this.getUserAccount().totalDeposits.sub(this.getUserAccount().totalWithdraws);
+        if (!position) {
+            return {
+                canBypass: false,
+                maxDepositAmount,
+                depositAmount: numericConstants_1.ZERO,
+                netDeposits,
+            };
+        }
+        if (types_1.isVariant(position.balanceType, 'borrow')) {
+            return {
+                canBypass: false,
+                maxDepositAmount,
+                netDeposits,
+                depositAmount: numericConstants_1.ZERO,
+            };
+        }
+        const depositAmount = spotBalance_1.getTokenAmount(position.scaledBalance, spotMarket, 'deposit');
+        if (netDeposits.lt(numericConstants_1.ZERO)) {
+            return {
+                canBypass: false,
+                maxDepositAmount,
+                depositAmount: numericConstants_1.ZERO,
+                netDeposits,
+            };
+        }
+        return {
+            canBypass: depositAmount.lt(maxDepositAmount),
+            maxDepositAmount,
+            netDeposits,
+            depositAmount,
+        };
+    }
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore
@@ -1037,7 +1095,7 @@ class User {
         const oracleData = this.getOracleDataForPerpMarket(marketToIgnore);
         let currentPerpPositionValueUSDC = numericConstants_1.ZERO;
         if (currentPerpPosition) {
-            currentPerpPositionValueUSDC = this.getPerpPositionValue(marketToIgnore, oracleData);
+            currentPerpPositionValueUSDC = this.getPerpPositionValue(marketToIgnore, oracleData, includeOpenOrders);
         }
         return this.getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders).sub(currentPerpPositionValueUSDC);
     }

package/package.json

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

package/src/constants/numericConstants.ts

@@ -83,6 +83,8 @@ export const MARGIN_PRECISION = TEN_THOUSAND;
 export const BID_ASK_SPREAD_PRECISION = new BN(1000000); // 10^6
 export const LIQUIDATION_PCT_PRECISION = TEN_THOUSAND;
 
+export const FIVE_MINUTE = new BN(60 * 5);
+export const ONE_HOUR = new BN(60 * 60);
 export const ONE_YEAR = new BN(31536000);
 
 export const QUOTE_SPOT_MARKET_INDEX = 0;

package/src/driftClient.ts

@@ -2950,6 +2950,70 @@ export class DriftClient {
 			maxTs: openOrder.maxTs,
 			auctionStartPrice: openOrder.auctionStartPrice,
 			auctionEndPrice: openOrder.auctionEndPrice,
+			userOrderId: openOrder.userOrderId,
+		};
+		const placeOrderIx = await this.getPlacePerpOrderIx(newOrderParams);
+
+		const tx = new Transaction();
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: 1_000_000,
+				additionalFee: 0,
+			})
+		);
+		tx.add(cancelOrderIx);
+		tx.add(placeOrderIx);
+		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+		this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+		return txSig;
+	}
+
+	/**
+	 * Modifies an open order by closing it and replacing it with a new order.
+	 * @param userOrderId: The open order to modify
+	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @returns
+	 */
+	public async modifyPerpOrderByUserOrderId(
+		userOrderId: number,
+		newBaseAmount?: BN,
+		newLimitPrice?: BN,
+		newOraclePriceOffset?: number
+	): Promise<TransactionSignature> {
+		if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
+			throw new Error(
+				`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`
+			);
+		}
+
+		const openOrder = this.getUser().getOrderByUserOrderId(userOrderId);
+		if (!openOrder) {
+			throw new Error(
+				`No open order with user order id ${userOrderId.toString()}`
+			);
+		}
+		const cancelOrderIx = await this.getCancelOrderIx(openOrder.orderId);
+
+		const newOrderParams: OptionalOrderParams = {
+			orderType: openOrder.orderType,
+			marketType: openOrder.marketType,
+			direction: openOrder.direction,
+			baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
+			price: newLimitPrice || openOrder.price,
+			marketIndex: openOrder.marketIndex,
+			reduceOnly: openOrder.reduceOnly,
+			postOnly: openOrder.postOnly,
+			immediateOrCancel: openOrder.immediateOrCancel,
+			triggerPrice: openOrder.triggerPrice,
+			triggerCondition: openOrder.triggerCondition,
+			oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
+			auctionDuration: openOrder.auctionDuration,
+			maxTs: openOrder.maxTs,
+			auctionStartPrice: openOrder.auctionStartPrice,
+			auctionEndPrice: openOrder.auctionEndPrice,
+			userOrderId: openOrder.userOrderId,
 		};
 		const placeOrderIx = await this.getPlacePerpOrderIx(newOrderParams);
 

package/src/idl/drift.json

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

package/src/math/margin.ts

@@ -22,7 +22,7 @@ export function calculateSizePremiumLiabilityWeight(
 		return liabilityWeight;
 	}
 
-	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+	const sizeSqrt = squareRootBN(size.abs().mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
 
 	const denom0 = BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor));
 	assert(denom0.gt(ZERO));
@@ -57,7 +57,7 @@ export function calculateSizeDiscountAssetWeight(
 		return assetWeight;
 	}
 
-	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+	const sizeSqrt = squareRootBN(size.abs().mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
 	const imfNumerator = SPOT_MARKET_IMF_PRECISION.add(
 		SPOT_MARKET_IMF_PRECISION.div(new BN(10))
 	);
@@ -106,17 +106,19 @@ export function calculateOraclePriceForPerpMargin(
 export function calculateBaseAssetValueWithOracle(
 	market: PerpMarketAccount,
 	perpPosition: PerpPosition,
-	oraclePriceData: OraclePriceData
+	oraclePriceData: OraclePriceData,
+	includeOpenOrders = false
 ): BN {
 	let price = oraclePriceData.price;
 	if (isVariant(market.status, 'settlement')) {
 		price = market.expiryPrice;
 	}
 
-	return perpPosition.baseAssetAmount
-		.abs()
-		.mul(price)
-		.div(AMM_RESERVE_PRECISION);
+	const baseAssetAmount = includeOpenOrders
+		? calculateWorstCaseBaseAssetAmount(perpPosition)
+		: perpPosition.baseAssetAmount;
+
+	return baseAssetAmount.abs().mul(price).div(AMM_RESERVE_PRECISION);
 }
 
 export function calculateWorstCaseBaseAssetAmount(