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

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;
@@ -259,14 +260,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 +318,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 +347,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 +357,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 +377,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 +401,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 +424,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 +434,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 +443,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 +489,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);
@@ -599,16 +614,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 +641,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 +661,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,7 +777,7 @@ 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 currentPerpPosition = this.getPerpPosition(perpPosition.marketIndex) ||
@@ -765,7 +789,7 @@ 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),
@@ -783,59 +807,48 @@ class User {
         const proposedPerpPositionValue = 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.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, proposedPerpPosition, this.getOracleDataForPerpMarket(market.marketIndex));
+        const marginRequirementOfTargetMarket = positionValue
+            .mul(new _1.BN(_1.calculateMarketMarginRatio(market, proposedPerpPosition.baseAssetAmount.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
+        const marginRequirementTargetMarket = proposedPerpPositionValue
             .mul(new _1.BN(_1.calculateMarketMarginRatio(market, proposedPerpPosition.baseAssetAmount.abs(), 'Maintenance')))
-            .div(numericConstants_1.MARGIN_PRECISION));
+            .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, proposedPerpPosition.baseAssetAmount, '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.
@@ -960,16 +973,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 +1007,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 +1041,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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.13.0-beta.0",
+	"version": "2.13.0-beta.1",
 	"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.1",
   "name": "drift",
   "instructions": [
     {

package/src/math/market.ts

@@ -5,6 +5,7 @@ import {
 	MarginCategory,
 	SpotMarketAccount,
 	SpotBalanceType,
+	MarketType,
 } from '../types';
 import {
 	calculateAmmReservesAfterSwap,
@@ -12,6 +13,7 @@ import {
 	calculateUpdatedAMMSpreadReserves,
 	getSwapDirection,
 	calculateUpdatedAMM,
+	calculateMarketOpenBidAsk,
 } from './amm';
 import {
 	calculateSizeDiscountAssetWeight,
@@ -25,6 +27,7 @@ import {
 	ZERO,
 } from '../constants/numericConstants';
 import { getTokenAmount } from './spotBalance';
+import { DLOB } from '../dlob/DLOB';
 
 /**
  * Calculates market mark price
@@ -232,3 +235,51 @@ export function calculateNetUserPnlImbalance(
 
 	return imbalance;
 }
+
+export function calculateAvailablePerpLiquidity(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	dlob: DLOB,
+	slot: number
+): { bids: BN; asks: BN } {
+	let [bids, asks] = calculateMarketOpenBidAsk(
+		market.amm.baseAssetReserve,
+		market.amm.minBaseAssetReserve,
+		market.amm.maxBaseAssetReserve,
+		market.amm.orderStepSize
+	);
+
+	asks = asks.abs();
+
+	const bidPrice = calculateBidPrice(market, oraclePriceData);
+	const askPrice = calculateAskPrice(market, oraclePriceData);
+
+	for (const bid of dlob.getMakerLimitBids(
+		market.marketIndex,
+		slot,
+		MarketType.PERP,
+		oraclePriceData,
+		askPrice
+	)) {
+		bids = bids.add(
+			bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled)
+		);
+	}
+
+	for (const ask of dlob.getMakerLimitAsks(
+		market.marketIndex,
+		slot,
+		MarketType.PERP,
+		oraclePriceData,
+		bidPrice
+	)) {
+		asks = asks.add(
+			ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled)
+		);
+	}
+
+	return {
+		bids: bids,
+		asks: asks,
+	};
+}

package/src/math/oracles.ts

@@ -6,8 +6,10 @@ import {
 	PRICE_PRECISION,
 	ONE,
 	ZERO,
+	FIVE_MINUTE,
+	ONE_HOUR,
 } from '../constants/numericConstants';
-import { BN, PerpMarketAccount } from '../index';
+import { BN, HistoricalOracleData, PerpMarketAccount } from '../index';
 import { assert } from '../assert/assert';
 
 export function oraclePriceBands(
@@ -68,7 +70,7 @@ export function isOracleTooDivergent(
 	const sinceLastUpdate = now.sub(
 		amm.historicalOracleData.lastOraclePriceTwapTs
 	);
-	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
+	const sinceStart = BN.max(ZERO, FIVE_MINUTE.sub(sinceLastUpdate));
 	const oracleTwap5min = amm.historicalOracleData.lastOraclePriceTwap5Min
 		.mul(sinceStart)
 		.add(oraclePriceData.price)
@@ -90,29 +92,36 @@ export function isOracleTooDivergent(
 }
 
 export function calculateLiveOracleTwap(
-	amm: AMM,
+	histOracleData: HistoricalOracleData,
 	oraclePriceData: OraclePriceData,
-	now: BN
+	now: BN,
+	period: BN
 ): BN {
+	let oracleTwap = undefined;
+	if (period.eq(ONE_HOUR)) {
+		//todo: assumes its 1hr
+		// period = amm.fundingPeriod;
+		oracleTwap = histOracleData.lastOraclePriceTwap;
+	} else if (period.eq(FIVE_MINUTE)) {
+		histOracleData.lastOraclePriceTwap5Min;
+	} else {
+		throw Error('unsupported twap period passed');
+	}
+
 	const sinceLastUpdate = BN.max(
 		ONE,
-		now.sub(amm.historicalOracleData.lastOraclePriceTwapTs)
+		now.sub(histOracleData.lastOraclePriceTwapTs)
 	);
-	const sinceStart = BN.max(ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+	const sinceStart = BN.max(ZERO, period.sub(sinceLastUpdate));
 
-	const clampRange = amm.historicalOracleData.lastOraclePriceTwap.div(
-		new BN(3)
-	);
+	const clampRange = oracleTwap.div(new BN(3));
 
 	const clampedOraclePrice = BN.min(
-		amm.historicalOracleData.lastOraclePriceTwap.add(clampRange),
-		BN.max(
-			oraclePriceData.price,
-			amm.historicalOracleData.lastOraclePriceTwap.sub(clampRange)
-		)
+		oracleTwap.add(clampRange),
+		BN.max(oraclePriceData.price, oracleTwap.sub(clampRange))
 	);
 
-	const newOracleTwap = amm.historicalOracleData.lastOraclePriceTwap
+	const newOracleTwap = oracleTwap
 		.mul(sinceStart)
 		.add(clampedOraclePrice.mul(sinceLastUpdate))
 		.div(sinceStart.add(sinceLastUpdate));
@@ -131,7 +140,12 @@ export function calculateLiveOracleStd(
 	);
 	const sinceStart = BN.max(ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
 
-	const liveOracleTwap = calculateLiveOracleTwap(amm, oraclePriceData, now);
+	const liveOracleTwap = calculateLiveOracleTwap(
+		amm.historicalOracleData,
+		oraclePriceData,
+		now,
+		amm.fundingPeriod
+	);
 
 	const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).abs();