@drift-labs/sdk 2.31.1-beta.23 → 2.31.1-beta.24

package/VERSION

@@ -1 +1 @@
-2.31.1-beta.23
+2.31.1-beta.24

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.31.1-beta.22",
+    "version": "2.31.1-beta.23",
     "name": "drift",
     "instructions": [
         {

package/lib/math/utils.d.ts

@@ -2,6 +2,7 @@ import { BN } from '../';
 export declare function clampBN(x: BN, min: BN, max: BN): BN;
 export declare const squareRootBN: (n: BN) => BN;
 export declare const divCeil: (a: BN, b: BN) => BN;
+export declare const sigNum: (x: BN) => BN;
 /**
  * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
  * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates

package/lib/math/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeRemainingUntilUpdate = exports.divCeil = exports.squareRootBN = exports.clampBN = void 0;
+exports.timeRemainingUntilUpdate = exports.sigNum = exports.divCeil = exports.squareRootBN = exports.clampBN = void 0;
 const __1 = require("../");
 function clampBN(x, min, max) {
     return __1.BN.max(min, __1.BN.min(x, max));
@@ -34,6 +34,10 @@ const divCeil = (a, b) => {
     }
 };
 exports.divCeil = divCeil;
+const sigNum = (x) => {
+    return x.isNeg() ? new __1.BN(-1) : new __1.BN(1);
+};
+exports.sigNum = sigNum;
 /**
  * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
  * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates

package/lib/user.d.ts

@@ -42,6 +42,7 @@ export declare class User {
      * @returns userSpotPosition
      */
     getSpotPosition(marketIndex: number): SpotPosition | undefined;
+    getEmptySpotPosition(marketIndex: number): SpotPosition;
     /**
      * 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.
@@ -160,6 +161,12 @@ export declare class User {
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage(): BN;
+    calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }: {
+        perpLiabilityValue: BN;
+        perpPnl: BN;
+        spotAssetValue: BN;
+        spotLiabilityValue: BN;
+    }): BN;
     getLeverageComponents(): {
         perpLiabilityValue: BN;
         perpPnl: BN;
@@ -252,6 +259,44 @@ export declare class User {
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
     getMaxTradeSizeUSDCForSpot(targetMarketIndex: number, direction: PositionDirection, currentQuoteAssetValue?: BN, currentSpotMarketNetValue?: BN): BN;
+    /**
+     * 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, }: {
+        inMarketIndex: number;
+        outMarketIndex: number;
+        calculateSwap?: (inAmount: BN) => BN;
+        iterationLimit?: number;
+    }): {
+        inAmount: BN;
+        outAmount: BN;
+        leverage: BN;
+    };
+    cloneAndUpdateSpotPosition(position: SpotPosition, tokenAmount: BN, market: SpotMarketAccount): SpotPosition;
+    calculateSpotPositionFreeCollateralContribution(spotPosition: SpotPosition): BN;
+    calculateSpotPositionLeverageContribution(spotPosition: SpotPosition): {
+        totalAssetValue: BN;
+        totalLiabilityValue: BN;
+    };
+    /**
+     * Estimates what the user leverage will be after swap
+     * @param inMarketIndex
+     * @param outMarketIndex
+     * @param inAmount
+     * @param outAmount
+     */
+    accountLeverageAfterSwap({ inMarketIndex, outMarketIndex, inAmount, outAmount, }: {
+        inMarketIndex: number;
+        outMarketIndex: number;
+        inAmount: BN;
+        outAmount: BN;
+    }): BN;
     /**
      * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
      * @param targetMarketIndex

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;
@@ -492,7 +503,8 @@ class User {
         return assetValue;
     }
     getSpotTokenAmount(marketIndex) {
-        const spotPosition = this.getSpotPosition(marketIndex);
+        var _a;
+        const spotPosition = (_a = this.getSpotPosition(marketIndex)) !== null && _a !== void 0 ? _a : this.getEmptySpotPosition(marketIndex);
         return (0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, this.driftClient.getSpotMarketAccount(marketIndex), spotPosition.balanceType);
     }
     getSpotPositionValue(marketIndex, marginCategory, includeOpenOrders, strict = false, now) {
@@ -671,8 +683,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);
@@ -1089,6 +1102,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.getSpotTokenAmount(inMarketIndex);
+        if (freeCollateral.lt(numericConstants_1.ONE)) {
+            if (outSaferThanIn) {
+                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.23",
+	"version": "2.31.1-beta.24",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.31.1-beta.23",
+  "version": "2.31.1-beta.24",
   "name": "drift",
   "instructions": [
     {

package/src/math/utils.ts

@@ -34,6 +34,10 @@ export const divCeil = (a: BN, b: BN): BN => {
 	}
 };
 
+export const sigNum = (x: BN): BN => {
+	return x.isNeg() ? new BN(-1) : new BN(1);
+};
+
 /**
  * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
  * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates

package/src/user.ts

@@ -28,6 +28,8 @@ import {
 	OPEN_ORDER_MARGIN_REQUIREMENT,
 	FIVE_MINUTE,
 	BASE_PRECISION,
+	ONE,
+	TWO,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -50,6 +52,8 @@ import {
 	calculateSpotMarketMarginRatio,
 	getSignedTokenAmount,
 	SpotBalanceType,
+	sigNum,
+	getBalance,
 } from '.';
 import {
 	getTokenAmount,
@@ -165,6 +169,18 @@ export class User {
 		);
 	}
 
+	getEmptySpotPosition(marketIndex: number): SpotPosition {
+		return {
+			marketIndex,
+			scaledBalance: ZERO,
+			balanceType: SpotBalanceType.DEPOSIT,
+			cumulativeDeposits: ZERO,
+			openAsks: ZERO,
+			openBids: 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.
@@ -442,7 +458,7 @@ export class User {
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getFreeCollateral(): BN {
-		const totalCollateral = this.getTotalCollateral();
+		const totalCollateral = this.getTotalCollateral('Initial', true);
 		const initialMarginRequirement = this.getInitialMarginRequirement();
 		const freeCollateral = totalCollateral.sub(initialMarginRequirement);
 		return freeCollateral.gte(ZERO) ? freeCollateral : ZERO;
@@ -919,7 +935,9 @@ export class User {
 	}
 
 	public getSpotTokenAmount(marketIndex: number): BN {
-		const spotPosition = this.getSpotPosition(marketIndex);
+		const spotPosition =
+			this.getSpotPosition(marketIndex) ??
+			this.getEmptySpotPosition(marketIndex);
 		return getTokenAmount(
 			spotPosition.scaledBalance,
 			this.driftClient.getSpotMarketAccount(marketIndex),
@@ -1231,10 +1249,20 @@ export class User {
 	 * @returns : Precision TEN_THOUSAND
 	 */
 	public getLeverage(): BN {
-		// get leverage components
-		const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } =
-			this.getLeverageComponents();
+		return this.calculateLeverageFromComponents(this.getLeverageComponents());
+	}
 
+	calculateLeverageFromComponents({
+		perpLiabilityValue,
+		perpPnl,
+		spotAssetValue,
+		spotLiabilityValue,
+	}: {
+		perpLiabilityValue: BN;
+		perpPnl: BN;
+		spotAssetValue: BN;
+		spotLiabilityValue: BN;
+	}): BN {
 		const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
 		const totalAssetValue = spotAssetValue.add(perpPnl);
 		const netAssetValue = totalAssetValue.sub(spotLiabilityValue);
@@ -1962,6 +1990,427 @@ export 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
+	 */
+	public getMaxSwapAmount({
+		inMarketIndex,
+		outMarketIndex,
+		calculateSwap,
+		iterationLimit = 1000,
+	}: {
+		inMarketIndex: number;
+		outMarketIndex: number;
+		calculateSwap?: (inAmount: BN) => BN;
+		iterationLimit?: number;
+	}): { inAmount: BN; outAmount: BN; leverage: BN } {
+		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 BN(10 ** inMarket.decimals);
+		const outPrecision = new 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: BN) => {
+				return inSwap
+					.mul(outPrecision)
+					.mul(inOraclePrice)
+					.div(outOraclePrice)
+					.div(inPrecision);
+			};
+		}
+
+		let inSwap = ZERO;
+		let outSwap = ZERO;
+		const inTokenAmount = this.getSpotTokenAmount(inMarketIndex);
+		if (freeCollateral.lt(ONE)) {
+			if (outSaferThanIn) {
+				inSwap = inTokenAmount;
+				outSwap = calculateSwap(inSwap);
+			}
+		} else {
+			let minSwap = ZERO;
+			let maxSwap = freeCollateral
+				.mul(inPrecision)
+				.mul(SPOT_MARKET_WEIGHT_PRECISION)
+				.div(SPOT_MARKET_WEIGHT_PRECISION.div(new BN(100)))
+				.div(inOraclePrice); // just assume user can go 100x
+			inSwap = maxSwap.div(TWO);
+			const error = BN.min(QUOTE_PRECISION, freeCollateral.div(new 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(TWO);
+				} else if (freeCollateralAfter.isNeg()) {
+					maxSwap = inSwap;
+					inSwap = minSwap.add(maxSwap).div(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: SpotPosition,
+		tokenAmount: BN,
+		market: SpotMarketAccount
+	): SpotPosition {
+		const clonedPosition = Object.assign({}, position);
+		if (tokenAmount.eq(ZERO)) {
+			return clonedPosition;
+		}
+
+		const preTokenAmount = getSignedTokenAmount(
+			getTokenAmount(position.scaledBalance, market, position.balanceType),
+			position.balanceType
+		);
+
+		if (sigNum(preTokenAmount).eq(sigNum(tokenAmount))) {
+			const scaledBalanceDelta = getBalance(
+				tokenAmount.abs(),
+				market,
+				position.balanceType
+			);
+			clonedPosition.scaledBalance =
+				clonedPosition.scaledBalance.add(scaledBalanceDelta);
+			return clonedPosition;
+		}
+
+		const updateDirection = tokenAmount.isNeg()
+			? SpotBalanceType.BORROW
+			: SpotBalanceType.DEPOSIT;
+
+		if (tokenAmount.abs().gte(preTokenAmount.abs())) {
+			clonedPosition.scaledBalance = getBalance(
+				tokenAmount.abs().sub(preTokenAmount.abs()),
+				market,
+				updateDirection
+			);
+			clonedPosition.balanceType = updateDirection;
+		} else {
+			const scaledBalanceDelta = getBalance(
+				tokenAmount.abs(),
+				market,
+				position.balanceType
+			);
+
+			clonedPosition.scaledBalance =
+				clonedPosition.scaledBalance.sub(scaledBalanceDelta);
+		}
+		return clonedPosition;
+	}
+
+	calculateSpotPositionFreeCollateralContribution(
+		spotPosition: SpotPosition
+	): BN {
+		let freeCollateralContribution = ZERO;
+		const now = new BN(new Date().getTime() / 1000);
+		const strict = true;
+		const marginCategory = 'Initial';
+
+		const spotMarketAccount: SpotMarketAccount =
+			this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+
+		const oraclePriceData = this.getOracleDataForSpotMarket(
+			spotPosition.marketIndex
+		);
+
+		const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] =
+			getWorstCaseTokenAmounts(
+				spotPosition,
+				spotMarketAccount,
+				oraclePriceData
+			);
+
+		if (worstCaseTokenAmount.gt(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: SpotPosition): {
+		totalAssetValue: BN;
+		totalLiabilityValue: BN;
+	} {
+		let totalAssetValue = ZERO;
+		let totalLiabilityValue = ZERO;
+		const now = new BN(new Date().getTime() / 1000);
+
+		const spotMarketAccount: SpotMarketAccount =
+			this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+
+		const oraclePriceData = this.getOracleDataForSpotMarket(
+			spotPosition.marketIndex
+		);
+
+		const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] =
+			getWorstCaseTokenAmounts(
+				spotPosition,
+				spotMarketAccount,
+				oraclePriceData
+			);
+
+		if (worstCaseTokenAmount.gt(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(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
+	 */
+	public accountLeverageAfterSwap({
+		inMarketIndex,
+		outMarketIndex,
+		inAmount,
+		outAmount,
+	}: {
+		inMarketIndex: number;
+		outMarketIndex: number;
+		inAmount: BN;
+		outAmount: BN;
+	}): BN {
+		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?
 
 	/**