@drift-labs/sdk 2.31.1-beta.9 → 2.32.1-beta.0

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;
@@ -918,15 +934,6 @@ export class User {
 		return assetValue;
 	}
 
-	public getSpotTokenAmount(marketIndex: number): BN {
-		const spotPosition = this.getSpotPosition(marketIndex);
-		return getTokenAmount(
-			spotPosition.scaledBalance,
-			this.driftClient.getSpotMarketAccount(marketIndex),
-			spotPosition.balanceType
-		);
-	}
-
 	public getSpotPositionValue(
 		marketIndex: number,
 		marginCategory?: MarginCategory,
@@ -1231,10 +1238,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);
@@ -1925,7 +1942,7 @@ export class User {
 				const marginRatio = calculateSpotMarketMarginRatio(
 					market,
 					'Initial',
-					this.getSpotTokenAmount(targetMarketIndex),
+					this.getTokenAmount(targetMarketIndex).abs(),
 					SpotBalanceType.BORROW
 				);
 				freeCollateral = freeCollateral.add(
@@ -1939,7 +1956,7 @@ export class User {
 				const marginRatio = calculateSpotMarketMarginRatio(
 					market,
 					'Initial',
-					this.getSpotTokenAmount(targetMarketIndex),
+					this.getTokenAmount(targetMarketIndex),
 					SpotBalanceType.DEPOSIT
 				);
 				freeCollateral = freeCollateral.add(
@@ -1962,6 +1979,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.getTokenAmount(inMarketIndex);
+		if (freeCollateral.lt(ONE)) {
+			if (outSaferThanIn && inTokenAmount.gt(ZERO)) {
+				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 };
+	}
+
+	public 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?
 
 	/**

package/tests/spot/test.ts

@@ -0,0 +1,156 @@
+import {
+	BN,
+	ZERO,
+	calculateSpotMarketBorrowCapacity,
+	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION,
+} from '../../src';
+import { mockSpotMarkets } from '../dlob/helpers';
+
+import { assert } from '../../src/assert/assert';
+
+describe('Spot Tests', () => {
+	it('base borrow capacity', () => {
+		const mockSpot = mockSpotMarkets[0];
+		mockSpot.maxBorrowRate = 1000000;
+		mockSpot.optimalBorrowRate = 100000;
+		mockSpot.optimalUtilization = 700000;
+
+		mockSpot.decimals = 9;
+		mockSpot.cumulativeDepositInterest =
+			SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION;
+		mockSpot.cumulativeBorrowInterest =
+			SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION;
+
+		const tokenAmount = 100000;
+		// no borrows
+		mockSpot.depositBalance = new BN(tokenAmount * 1e9);
+		mockSpot.borrowBalance = ZERO;
+
+		// todo, should incorp all other spot market constraints?
+		const aboveMaxAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(2000000)
+		);
+		assert(aboveMaxAmount.gt(mockSpot.depositBalance));
+
+		const maxAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(1000000)
+		);
+		assert(maxAmount.eq(mockSpot.depositBalance));
+
+		const optAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(100000)
+		);
+		const ans = new BN((mockSpot.depositBalance.toNumber() * 7) / 10);
+		// console.log('optAmount:', optAmount.toNumber(), ans.toNumber());
+		assert(optAmount.eq(ans));
+
+		const betweenOptMaxAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(810000)
+		);
+		// console.log('betweenOptMaxAmount:', betweenOptMaxAmount.toNumber());
+		assert(betweenOptMaxAmount.lt(mockSpot.depositBalance));
+		assert(betweenOptMaxAmount.gt(ans));
+		assert(betweenOptMaxAmount.eq(new BN(93666600000000)));
+
+		const belowOptAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(50000)
+		);
+		// console.log('belowOptAmount:', belowOptAmount.toNumber());
+		assert(belowOptAmount.eq(ans.div(new BN(2))));
+
+		const belowOptAmount2 = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(24900)
+		);
+		// console.log('belowOptAmount2:', belowOptAmount2.toNumber());
+		assert(belowOptAmount2.lt(ans.div(new BN(4))));
+		assert(belowOptAmount2.eq(new BN('17430000000000')));
+
+		const belowOptAmount3 = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(1)
+		);
+		// console.log('belowOptAmount3:', belowOptAmount3.toNumber());
+		assert(belowOptAmount3.eq(new BN('700000000'))); //0.7
+	});
+
+	it('complex borrow capacity', () => {
+		const mockSpot = mockSpotMarkets[0];
+		mockSpot.maxBorrowRate = 1000000;
+		mockSpot.optimalBorrowRate = 70000;
+		mockSpot.optimalUtilization = 700000;
+
+		mockSpot.decimals = 9;
+		mockSpot.cumulativeDepositInterest = new BN(
+			1.0154217042 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber()
+		);
+		mockSpot.cumulativeBorrowInterest = new BN(
+			1.0417153549 * SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION.toNumber()
+		);
+
+		mockSpot.depositBalance = new BN(88522.734106451 * 1e9);
+		mockSpot.borrowBalance = new BN(7089.91675884 * 1e9);
+
+		// todo, should incorp all other spot market constraints?
+		const aboveMaxAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(2000000)
+		);
+		assert(aboveMaxAmount.eq(new BN('111498270939007')));
+
+		const maxAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(1000000)
+		);
+		assert(maxAmount.eq(new BN('82502230374168')));
+		// console.log('aboveMaxAmount:', aboveMaxAmount.toNumber(), 'maxAmount:', maxAmount.toNumber());
+		const optAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(70000)
+		);
+		// console.log('optAmount:', optAmount.toNumber());
+		assert(optAmount.eq(new BN('55535858716123'))); // ~ 55535
+
+		const betweenOptMaxAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(810000)
+		);
+		// console.log('betweenOptMaxAmount:', betweenOptMaxAmount.toNumber());
+		assert(betweenOptMaxAmount.lt(maxAmount));
+		assert(betweenOptMaxAmount.eq(new BN(76992910756523)));
+		assert(betweenOptMaxAmount.gt(optAmount));
+
+		const belowOptAmount = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(50000)
+		);
+		// console.log('belowOptAmount:', belowOptAmount.toNumber());
+		assert(belowOptAmount.eq(new BN('37558277610760')));
+
+		const belowOptAmount2 = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(24900)
+		);
+		// console.log('belowOptAmount2:', belowOptAmount2.toNumber());
+		assert(belowOptAmount2.eq(new BN('14996413323529')));
+
+		const belowOptAmount3 = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(4900)
+		);
+		// console.log('belowOptAmount2:', belowOptAmount3.toNumber());
+		assert(belowOptAmount3.eq(new BN('0')));
+
+		const belowOptAmount4 = calculateSpotMarketBorrowCapacity(
+			mockSpot,
+			new BN(1)
+		);
+		// console.log('belowOptAmount3:', belowOptAmount4.toNumber());
+		assert(belowOptAmount4.eq(new BN('0')));
+	});
+});