@drift-labs/sdk 2.31.1-beta.9 → 2.32.0

package/lib/user.js

@@ -80,6 +80,17 @@ class User {
     getSpotPosition(marketIndex) {
         return this.getUserAccount().spotPositions.find((position) => position.marketIndex === marketIndex);
     }
+    getEmptySpotPosition(marketIndex) {
+        return {
+            marketIndex,
+            scaledBalance: numericConstants_1.ZERO,
+            balanceType: _1.SpotBalanceType.DEPOSIT,
+            cumulativeDeposits: numericConstants_1.ZERO,
+            openAsks: numericConstants_1.ZERO,
+            openBids: numericConstants_1.ZERO,
+            openOrders: 0,
+        };
+    }
     /**
      * Returns the token amount for a given market. The spot market precision is based on the token mint decimals.
      * Positive if it is a deposit, negative if it is a borrow.
@@ -282,7 +293,7 @@ class User {
      * @returns : Precision QUOTE_PRECISION
      */
     getFreeCollateral() {
-        const totalCollateral = this.getTotalCollateral();
+        const totalCollateral = this.getTotalCollateral('Initial', true);
         const initialMarginRequirement = this.getInitialMarginRequirement();
         const freeCollateral = totalCollateral.sub(initialMarginRequirement);
         return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
@@ -491,10 +502,6 @@ class User {
         }
         return assetValue;
     }
-    getSpotTokenAmount(marketIndex) {
-        const spotPosition = this.getSpotPosition(marketIndex);
-        return (0, 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);
@@ -671,8 +678,9 @@ class User {
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage() {
-        // get leverage components
-        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        return this.calculateLeverageFromComponents(this.getLeverageComponents());
+    }
+    calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }) {
         const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
         const totalAssetValue = spotAssetValue.add(perpPnl);
         const netAssetValue = totalAssetValue.sub(spotLiabilityValue);
@@ -1070,13 +1078,13 @@ class User {
             // if the user is buying/selling and already short/long, need to account for closing out short/long
             if ((0, types_1.isVariant)(direction, 'long') && currentSpotMarketNetValue.lt(numericConstants_1.ZERO)) {
                 tradeAmount = currentSpotMarketNetValue.abs();
-                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, 'Initial', this.getSpotTokenAmount(targetMarketIndex), _1.SpotBalanceType.BORROW);
+                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, 'Initial', this.getTokenAmount(targetMarketIndex).abs(), _1.SpotBalanceType.BORROW);
                 freeCollateral = freeCollateral.add(tradeAmount.mul(new _1.BN(marginRatio)).div(numericConstants_1.MARGIN_PRECISION));
             }
             else if ((0, types_1.isVariant)(direction, 'short') &&
                 currentSpotMarketNetValue.gt(numericConstants_1.ZERO)) {
                 tradeAmount = currentSpotMarketNetValue;
-                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, 'Initial', this.getSpotTokenAmount(targetMarketIndex), _1.SpotBalanceType.DEPOSIT);
+                const marginRatio = (0, _1.calculateSpotMarketMarginRatio)(market, 'Initial', this.getTokenAmount(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)));
@@ -1089,6 +1097,216 @@ class User {
         }
         return tradeAmount;
     }
+    /**
+     * Calculates the max amount of token that can be swapped from inMarket to outMarket
+     * Assumes swap happens at oracle price
+     *
+     * @param inMarketIndex
+     * @param outMarketIndex
+     * @param calculateSwap function to similate in to out swa
+     * @param iterationLimit how long to run appromixation before erroring out
+     */
+    getMaxSwapAmount({ inMarketIndex, outMarketIndex, calculateSwap, iterationLimit = 1000, }) {
+        const inMarket = this.driftClient.getSpotMarketAccount(inMarketIndex);
+        const outMarket = this.driftClient.getSpotMarketAccount(outMarketIndex);
+        const inOraclePrice = this.getOracleDataForSpotMarket(inMarketIndex).price;
+        const outOraclePrice = this.getOracleDataForSpotMarket(outMarketIndex).price;
+        const inPrecision = new _1.BN(10 ** inMarket.decimals);
+        const outPrecision = new _1.BN(10 ** outMarket.decimals);
+        const outSaferThanIn = inMarket.initialAssetWeight < outMarket.initialAssetWeight;
+        const inSpotPosition = this.getSpotPosition(inMarketIndex) ||
+            this.getEmptySpotPosition(inMarketIndex);
+        const outSpotPosition = this.getSpotPosition(outMarketIndex) ||
+            this.getEmptySpotPosition(outMarketIndex);
+        const freeCollateral = this.getFreeCollateral();
+        const inContributionInitial = this.calculateSpotPositionFreeCollateralContribution(inSpotPosition);
+        const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition);
+        const outContributionInitial = this.calculateSpotPositionFreeCollateralContribution(outSpotPosition);
+        const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition);
+        const initialContribution = inContributionInitial.add(outContributionInitial);
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        if (!calculateSwap) {
+            calculateSwap = (inSwap) => {
+                return inSwap
+                    .mul(outPrecision)
+                    .mul(inOraclePrice)
+                    .div(outOraclePrice)
+                    .div(inPrecision);
+            };
+        }
+        let inSwap = numericConstants_1.ZERO;
+        let outSwap = numericConstants_1.ZERO;
+        const inTokenAmount = this.getTokenAmount(inMarketIndex);
+        if (freeCollateral.lt(numericConstants_1.ONE)) {
+            if (outSaferThanIn && inTokenAmount.gt(numericConstants_1.ZERO)) {
+                inSwap = inTokenAmount;
+                outSwap = calculateSwap(inSwap);
+            }
+        }
+        else {
+            let minSwap = numericConstants_1.ZERO;
+            let maxSwap = freeCollateral
+                .mul(inPrecision)
+                .mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.div(new _1.BN(100)))
+                .div(inOraclePrice); // just assume user can go 100x
+            inSwap = maxSwap.div(numericConstants_1.TWO);
+            const error = _1.BN.min(numericConstants_1.QUOTE_PRECISION, freeCollateral.div(new _1.BN(100)));
+            let i = 0;
+            let freeCollateralAfter = freeCollateral;
+            while (freeCollateralAfter.gt(error) || freeCollateralAfter.isNeg()) {
+                outSwap = calculateSwap(inSwap);
+                const inPositionAfter = this.cloneAndUpdateSpotPosition(inSpotPosition, inSwap.neg(), inMarket);
+                const outPositionAfter = this.cloneAndUpdateSpotPosition(outSpotPosition, outSwap, outMarket);
+                const inContributionAfter = this.calculateSpotPositionFreeCollateralContribution(inPositionAfter);
+                const outContributionAfter = this.calculateSpotPositionFreeCollateralContribution(outPositionAfter);
+                const contributionAfter = inContributionAfter.add(outContributionAfter);
+                const contributionDelta = contributionAfter.sub(initialContribution);
+                freeCollateralAfter = freeCollateral.add(contributionDelta);
+                if (freeCollateralAfter.gt(error)) {
+                    minSwap = inSwap;
+                    inSwap = minSwap.add(maxSwap).div(numericConstants_1.TWO);
+                }
+                else if (freeCollateralAfter.isNeg()) {
+                    maxSwap = inSwap;
+                    inSwap = minSwap.add(maxSwap).div(numericConstants_1.TWO);
+                }
+                if (i++ > iterationLimit) {
+                    throw new Error('getMaxSwapAmount iteration limit reached');
+                }
+            }
+        }
+        const inPositionAfter = this.cloneAndUpdateSpotPosition(inSpotPosition, inSwap.neg(), inMarket);
+        const outPositionAfter = this.cloneAndUpdateSpotPosition(outSpotPosition, outSwap, outMarket);
+        const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter);
+        const { totalAssetValue: outTotalAssetValueAfter, totalLiabilityValue: outTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(outPositionAfter);
+        const spotAssetValueDelta = inTotalAssetValueAfter
+            .add(outTotalAssetValueAfter)
+            .sub(inTotalAssetValueInitial)
+            .sub(outTotalAssetValueInitial);
+        const spotLiabilityValueDelta = inTotalLiabilityValueAfter
+            .add(outTotalLiabilityValueAfter)
+            .sub(inTotalLiabilityValueInitial)
+            .sub(outTotalLiabilityValueInitial);
+        const spotAssetValueAfter = spotAssetValue.add(spotAssetValueDelta);
+        const spotLiabilityValueAfter = spotLiabilityValue.add(spotLiabilityValueDelta);
+        const leverage = this.calculateLeverageFromComponents({
+            perpLiabilityValue,
+            perpPnl,
+            spotAssetValue: spotAssetValueAfter,
+            spotLiabilityValue: spotLiabilityValueAfter,
+        });
+        return { inAmount: inSwap, outAmount: outSwap, leverage };
+    }
+    cloneAndUpdateSpotPosition(position, tokenAmount, market) {
+        const clonedPosition = Object.assign({}, position);
+        if (tokenAmount.eq(numericConstants_1.ZERO)) {
+            return clonedPosition;
+        }
+        const preTokenAmount = (0, _1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(position.scaledBalance, market, position.balanceType), position.balanceType);
+        if ((0, _1.sigNum)(preTokenAmount).eq((0, _1.sigNum)(tokenAmount))) {
+            const scaledBalanceDelta = (0, _1.getBalance)(tokenAmount.abs(), market, position.balanceType);
+            clonedPosition.scaledBalance =
+                clonedPosition.scaledBalance.add(scaledBalanceDelta);
+            return clonedPosition;
+        }
+        const updateDirection = tokenAmount.isNeg()
+            ? _1.SpotBalanceType.BORROW
+            : _1.SpotBalanceType.DEPOSIT;
+        if (tokenAmount.abs().gte(preTokenAmount.abs())) {
+            clonedPosition.scaledBalance = (0, _1.getBalance)(tokenAmount.abs().sub(preTokenAmount.abs()), market, updateDirection);
+            clonedPosition.balanceType = updateDirection;
+        }
+        else {
+            const scaledBalanceDelta = (0, _1.getBalance)(tokenAmount.abs(), market, position.balanceType);
+            clonedPosition.scaledBalance =
+                clonedPosition.scaledBalance.sub(scaledBalanceDelta);
+        }
+        return clonedPosition;
+    }
+    calculateSpotPositionFreeCollateralContribution(spotPosition) {
+        let freeCollateralContribution = numericConstants_1.ZERO;
+        const now = new _1.BN(new Date().getTime() / 1000);
+        const strict = true;
+        const marginCategory = 'Initial';
+        const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+        const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+        const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, oraclePriceData);
+        if (worstCaseTokenAmount.gt(numericConstants_1.ZERO)) {
+            const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory, strict, now);
+            freeCollateralContribution =
+                freeCollateralContribution.add(baseAssetValue);
+        }
+        else {
+            const baseLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, marginCategory, undefined, strict, now).abs();
+            freeCollateralContribution =
+                freeCollateralContribution.sub(baseLiabilityValue);
+        }
+        freeCollateralContribution.add(worstCaseQuoteTokenAmount);
+        return freeCollateralContribution;
+    }
+    calculateSpotPositionLeverageContribution(spotPosition) {
+        let totalAssetValue = numericConstants_1.ZERO;
+        let totalLiabilityValue = numericConstants_1.ZERO;
+        const now = new _1.BN(new Date().getTime() / 1000);
+        const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+        const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+        const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, oraclePriceData);
+        if (worstCaseTokenAmount.gt(numericConstants_1.ZERO)) {
+            totalAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, undefined, false, now);
+        }
+        else {
+            totalLiabilityValue = this.getSpotLiabilityValue(worstCaseTokenAmount, oraclePriceData, spotMarketAccount, undefined, undefined, false, now).abs();
+        }
+        if (worstCaseQuoteTokenAmount.gt(numericConstants_1.ZERO)) {
+            totalAssetValue = totalAssetValue.add(worstCaseQuoteTokenAmount);
+        }
+        else {
+            totalLiabilityValue = totalLiabilityValue.add(worstCaseQuoteTokenAmount.abs());
+        }
+        return {
+            totalAssetValue,
+            totalLiabilityValue,
+        };
+    }
+    /**
+     * Estimates what the user leverage will be after swap
+     * @param inMarketIndex
+     * @param outMarketIndex
+     * @param inAmount
+     * @param outAmount
+     */
+    accountLeverageAfterSwap({ inMarketIndex, outMarketIndex, inAmount, outAmount, }) {
+        const inMarket = this.driftClient.getSpotMarketAccount(inMarketIndex);
+        const outMarket = this.driftClient.getSpotMarketAccount(outMarketIndex);
+        const inSpotPosition = this.getSpotPosition(inMarketIndex) ||
+            this.getEmptySpotPosition(inMarketIndex);
+        const outSpotPosition = this.getSpotPosition(outMarketIndex) ||
+            this.getEmptySpotPosition(outMarketIndex);
+        const { totalAssetValue: inTotalAssetValueInitial, totalLiabilityValue: inTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(inSpotPosition);
+        const { totalAssetValue: outTotalAssetValueInitial, totalLiabilityValue: outTotalLiabilityValueInitial, } = this.calculateSpotPositionLeverageContribution(outSpotPosition);
+        const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
+        const inPositionAfter = this.cloneAndUpdateSpotPosition(inSpotPosition, inAmount.abs().neg(), inMarket);
+        const outPositionAfter = this.cloneAndUpdateSpotPosition(outSpotPosition, outAmount.abs(), outMarket);
+        const { totalAssetValue: inTotalAssetValueAfter, totalLiabilityValue: inTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(inPositionAfter);
+        const { totalAssetValue: outTotalAssetValueAfter, totalLiabilityValue: outTotalLiabilityValueAfter, } = this.calculateSpotPositionLeverageContribution(outPositionAfter);
+        const spotAssetValueDelta = inTotalAssetValueAfter
+            .add(outTotalAssetValueAfter)
+            .sub(inTotalAssetValueInitial)
+            .sub(outTotalAssetValueInitial);
+        const spotLiabilityValueDelta = inTotalLiabilityValueAfter
+            .add(outTotalLiabilityValueAfter)
+            .sub(inTotalLiabilityValueInitial)
+            .sub(outTotalLiabilityValueInitial);
+        const spotAssetValueAfter = spotAssetValue.add(spotAssetValueDelta);
+        const spotLiabilityValueAfter = spotLiabilityValue.add(spotLiabilityValueDelta);
+        return this.calculateLeverageFromComponents({
+            perpLiabilityValue,
+            perpPnl,
+            spotAssetValue: spotAssetValueAfter,
+            spotLiabilityValue: spotLiabilityValueAfter,
+        });
+    }
     // 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

package/package.json

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

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;

package/src/constants/perpMarkets.ts

@@ -134,6 +134,16 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1683125906000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'RNDR',
+		category: ['Infra'],
+		symbol: 'RNDR-PERP',
+		baseAssetSymbol: 'RNDR',
+		marketIndex: 12,
+		oracle: new PublicKey('C2QvUPBiU3fViSyqA4nZgGyYqLgYf9PRpd8B8oLoo48w'),
+		launchTs: 1683125906000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const MainnetPerpMarkets: PerpMarketConfig[] = [
@@ -257,6 +267,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1683125906000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'RNDR',
+		category: ['Infra'],
+		symbol: 'RNDR-PERP',
+		baseAssetSymbol: 'RNDR',
+		marketIndex: 12,
+		oracle: new PublicKey('CYGfrBJB9HgLf9iZyN4aH5HvUAi2htQ4MjPxeXMf4Egn'),
+		launchTs: 1683125906000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/dlob/orderBookLevels.ts

@@ -12,6 +12,7 @@ import {
 	PositionDirection,
 	standardizePrice,
 	SwapDirection,
+	ZERO,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 
@@ -169,7 +170,7 @@ export function getVammL2Generator({
 		pegMultiplier: updatedAmm.pegMultiplier,
 	};
 	const getL2Bids = function* () {
-		while (numBids < numOrders) {
+		while (numBids < numOrders && baseSize.gt(ZERO)) {
 			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
 				calculateAmmReservesAfterSwap(
 					bidAmm,
@@ -208,7 +209,7 @@ export function getVammL2Generator({
 		pegMultiplier: updatedAmm.pegMultiplier,
 	};
 	const getL2Asks = function* () {
-		while (numAsks < numOrders) {
+		while (numAsks < numOrders && askSize.gt(ZERO)) {
 			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
 				calculateAmmReservesAfterSwap(
 					askAmm,