@velocity-exchange/sdk 0.1.0 → 0.2.1

package/src/math/margin.ts

@@ -8,7 +8,6 @@ import {
 	SPOT_MARKET_WEIGHT_PRECISION,
 	SPOT_MARKET_IMF_PRECISION,
 	ZERO,
-	BID_ASK_SPREAD_PRECISION,
 	AMM_RESERVE_PRECISION,
 	BASE_PRECISION,
 	MARGIN_PRECISION,
@@ -20,15 +19,7 @@ import { OraclePriceData } from '../oracles/types';
 import { calculateMarketMarginRatio } from './market';
 import { calculateScaledInitialAssetWeight } from './spotBalance';
 import { VelocityClient } from '../velocityClient';
-import { OneShotUserAccountSubscriber } from '../accounts/oneShotUserAccountSubscriber';
-import {
-	PerpMarketAccount,
-	PerpPosition,
-	PositionDirection,
-	UserAccount,
-} from '../types';
-import { PublicKey } from '@solana/web3.js';
-import { User } from '../user';
+import { PerpMarketAccount, PerpPosition } from '../types';
 import { isVariant } from '../types';
 import { assert } from '../assert/assert';
 
@@ -97,32 +88,6 @@ export function calculateSizeDiscountAssetWeight(
 	return minAssetWeight;
 }
 
-export function calculateOraclePriceForPerpMargin(
-	perpPosition: PerpPosition,
-	market: PerpMarketAccount,
-	oraclePriceData: OraclePriceData
-): BN {
-	const oraclePriceOffset = BN.min(
-		new BN(market.amm.maxSpread)
-			.mul(oraclePriceData.price)
-			.div(BID_ASK_SPREAD_PRECISION),
-		oraclePriceData.confidence.add(
-			new BN(market.amm.baseSpread)
-				.mul(oraclePriceData.price)
-				.div(BID_ASK_SPREAD_PRECISION)
-		)
-	);
-
-	let marginPrice: BN;
-	if (perpPosition.baseAssetAmount.gt(ZERO)) {
-		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
-	} else {
-		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
-	}
-
-	return marginPrice;
-}
-
 /**
  * This is _not_ the same as liability value as for prediction markets, the liability for the short in prediction market is (1 - oracle price) * base
  * See {@link calculatePerpLiabilityValue} to get the liabiltiy value
@@ -226,7 +191,8 @@ export function calculateMarginUSDCRequiredForTrade(
 	userMaxMarginRatio?: number,
 	entryPrice?: BN
 ): BN {
-	const targetMarket = velocityClient.getPerpMarketAccount(targetMarketIndex);
+	const targetMarket =
+		velocityClient.getPerpMarketAccountOrThrow(targetMarketIndex);
 
 	const price =
 		entryPrice ??
@@ -269,7 +235,8 @@ export function calculateCollateralDepositRequiredForTrade(
 		estEntryPrice
 	);
 
-	const collateralMarket = velocityClient.getSpotMarketAccount(collateralIndex);
+	const collateralMarket =
+		velocityClient.getSpotMarketAccountOrThrow(collateralIndex);
 
 	const collateralOracleData =
 		velocityClient.getOracleDataForSpotMarket(collateralIndex);
@@ -292,77 +259,3 @@ export function calculateCollateralDepositRequiredForTrade(
 
 	return baseAmountRequired;
 }
-
-export function calculateCollateralValueOfDeposit(
-	velocityClient: VelocityClient,
-	collateralIndex: number,
-	baseSize: BN
-): BN {
-	const collateralMarket = velocityClient.getSpotMarketAccount(collateralIndex);
-
-	const collateralOracleData =
-		velocityClient.getOracleDataForSpotMarket(collateralIndex);
-
-	const scaledAssetWeight = calculateScaledInitialAssetWeight(
-		collateralMarket,
-		collateralOracleData.price
-	);
-
-	// CollateralBaseValue = oracle price * collateral base amount (and shift to QUOTE_PRECISION)
-	const collateralBaseValue = collateralOracleData.price
-		.mul(baseSize)
-		.mul(QUOTE_PRECISION)
-		.div(PRICE_PRECISION)
-		.div(new BN(10).pow(new BN(collateralMarket.decimals)));
-
-	const depositCollateralValue = collateralBaseValue
-		.mul(scaledAssetWeight)
-		.div(SPOT_MARKET_WEIGHT_PRECISION);
-
-	return depositCollateralValue;
-}
-
-export function calculateLiquidationPrice(
-	freeCollateral: BN,
-	freeCollateralDelta: BN,
-	oraclePrice: BN
-): BN {
-	const liqPriceDelta = freeCollateral
-		.mul(QUOTE_PRECISION)
-		.div(freeCollateralDelta);
-
-	const liqPrice = oraclePrice.sub(liqPriceDelta);
-
-	if (liqPrice.lt(ZERO)) {
-		return new BN(-1);
-	}
-
-	return liqPrice;
-}
-
-export function calculateUserMaxPerpOrderSize(
-	velocityClient: VelocityClient,
-	userAccountKey: PublicKey,
-	userAccount: UserAccount,
-	targetMarketIndex: number,
-	tradeSide: PositionDirection
-): { tradeSize: BN; oppositeSideTradeSize: BN } {
-	const userAccountSubscriber = new OneShotUserAccountSubscriber(
-		velocityClient.program,
-		userAccountKey,
-		userAccount
-	);
-
-	const user = new User({
-		velocityClient,
-		userAccountPublicKey: userAccountKey,
-		accountSubscription: {
-			type: 'custom',
-			userAccountSubscriber: userAccountSubscriber,
-		},
-	});
-
-	user.isSubscribed = true;
-
-	return user.getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide);
-}

package/src/math/market.ts

@@ -5,16 +5,12 @@ import {
 	MarginCategory,
 	SpotMarketAccount,
 	SpotBalanceType,
-	MarketType,
 	isVariant,
 } from '../types';
 import {
-	calculateAmmReservesAfterSwap,
 	calculatePrice,
 	calculateUpdatedAMMSpreadReserves,
-	getSwapDirection,
 	calculateUpdatedAMM,
-	calculateMarketOpenBidAsk,
 } from './amm';
 import {
 	calculateSizeDiscountAssetWeight,
@@ -32,7 +28,6 @@ import {
 	FUNDING_RATE_PRECISION,
 } from '../constants/numericConstants';
 import { getTokenAmount } from './spotBalance';
-import { DLOB } from '../dlob/DLOB';
 import { assert } from '../assert/assert';
 
 /**
@@ -43,13 +38,9 @@ import { assert } from '../assert/assert';
  */
 export function calculateReservePrice(
 	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData
+	mmOraclePriceData?: MMOraclePriceData
 ): BN {
-	const newAmm = calculateUpdatedAMM(
-		market.amm,
-		market.totalExchangeFee,
-		mmOraclePriceData
-	);
+	const newAmm = calculateUpdatedAMM(market.amm, mmOraclePriceData);
 	return calculatePrice(
 		newAmm.baseAssetReserve,
 		newAmm.quoteAssetReserve,
@@ -65,14 +56,13 @@ export function calculateReservePrice(
  */
 export function calculateBidPrice(
 	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
+	mmOraclePriceData?: MMOraclePriceData,
 	latestSlot?: BN
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
 		calculateUpdatedAMMSpreadReserves(
 			market.amm,
 			market.marketStats,
-			market.totalExchangeFee,
 			PositionDirection.SHORT,
 			mmOraclePriceData,
 			latestSlot
@@ -89,14 +79,13 @@ export function calculateBidPrice(
  */
 export function calculateAskPrice(
 	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
+	mmOraclePriceData?: MMOraclePriceData,
 	latestSlot?: BN
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
 		calculateUpdatedAMMSpreadReserves(
 			market.amm,
 			market.marketStats,
-			market.totalExchangeFee,
 			PositionDirection.LONG,
 			mmOraclePriceData,
 			latestSlot
@@ -105,36 +94,6 @@ export function calculateAskPrice(
 	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 
-export function calculateNewMarketAfterTrade(
-	baseAssetAmount: BN,
-	direction: PositionDirection,
-	market: PerpMarketAccount
-): PerpMarketAccount {
-	const [newQuoteAssetReserve, newBaseAssetReserve] =
-		calculateAmmReservesAfterSwap(
-			market.amm,
-			'base',
-			baseAssetAmount.abs(),
-			getSwapDirection('base', direction)
-		);
-
-	const newAmm = Object.assign({}, market.amm);
-	const newMarket = Object.assign({}, market);
-	newMarket.amm = newAmm;
-	newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
-	newMarket.amm.baseAssetReserve = newBaseAssetReserve;
-
-	return newMarket;
-}
-
-export function calculateOracleReserveSpread(
-	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData
-): BN {
-	const reservePrice = calculateReservePrice(market, mmOraclePriceData);
-	return calculateOracleSpread(reservePrice, mmOraclePriceData);
-}
-
 export function calculateOracleSpread(
 	price: BN,
 	oraclePriceData: OraclePriceData
@@ -295,55 +254,6 @@ export function calculateNetUserPnlImbalance(
 	return imbalance;
 }
 
-export function calculateAvailablePerpLiquidity(
-	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
-	dlob: DLOB,
-	slot: number
-): { bids: BN; asks: BN } {
-	let [bids, asks] = calculateMarketOpenBidAsk(
-		market.amm.baseAssetReserve,
-		market.amm.minBaseAssetReserve,
-		market.amm.maxBaseAssetReserve,
-		market.orderStepSize
-	);
-
-	asks = asks.abs();
-
-	for (const bid of dlob.getRestingLimitBids(
-		market.marketIndex,
-		slot,
-		MarketType.PERP,
-		mmOraclePriceData
-	)) {
-		bids = bids.add(
-			bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled)
-		);
-	}
-
-	for (const ask of dlob.getRestingLimitAsks(
-		market.marketIndex,
-		slot,
-		MarketType.PERP,
-		mmOraclePriceData
-	)) {
-		asks = asks.add(
-			ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled)
-		);
-	}
-
-	return {
-		bids: bids,
-		asks: asks,
-	};
-}
-
-export function calculatePerpMarketBaseLiquidatorFee(
-	market: PerpMarketAccount
-): number {
-	return market.liquidatorFee;
-}
-
 /**
  * Calculates trigger price for a perp market based on oracle price and current time
  * Implements the same logic as the Rust get_trigger_price function
@@ -396,10 +306,10 @@ function getLastFundingBasis(
 	oraclePrice: BN,
 	now: BN
 ): BN {
-	if (market.lastFundingOracleTwap.gt(ZERO)) {
+	if (market.marketStats.lastFundingOracleTwap.gt(ZERO)) {
 		const lastFundingRate = market.lastFundingRate
 			.mul(PRICE_PRECISION)
-			.div(market.lastFundingOracleTwap)
+			.div(market.marketStats.lastFundingOracleTwap)
 			.muln(24);
 		const lastFundingRatePreAdj = lastFundingRate.sub(
 			FUNDING_RATE_PRECISION.div(new BN(3333)) // FUNDING_RATE_OFFSET_PERCENTAGE

package/src/math/oracles.ts

@@ -300,23 +300,6 @@ export function getNewOracleConfPct(
 	return confIntervalPctResult;
 }
 
-export function trimVaaSignatures(vaa: Buffer, n = 3): Buffer {
-	const currentNumSignatures = vaa[5];
-	if (n > currentNumSignatures) {
-		throw new Error(
-			"Resulting VAA can't have more signatures than the original VAA"
-		);
-	}
-
-	const trimmedVaa = Buffer.concat([
-		vaa.subarray(0, 6 + n * 66),
-		vaa.subarray(6 + currentNumSignatures * 66),
-	]);
-
-	trimmedVaa[5] = n;
-	return trimmedVaa;
-}
-
 export function getMultipleBetweenOracleSources(
 	firstOracleSource: OracleSource,
 	secondOracleSource: OracleSource

package/src/math/orders.ts

@@ -1,4 +1,3 @@
-import { User } from '../user';
 import {
 	isOneOfVariant,
 	isVariant,
@@ -13,7 +12,6 @@ import {
 } from '../types';
 import {
 	ZERO,
-	TWO,
 	ONE,
 	SPOT_MARKET_IMF_PRECISION,
 	MARGIN_PRECISION,
@@ -32,105 +30,6 @@ import {
 } from './amm';
 import { calculateSizePremiumLiabilityWeight } from './margin';
 
-export function isOrderRiskIncreasing(user: User, order: Order): boolean {
-	if (!isVariant(order.status, 'open')) {
-		return false;
-	}
-
-	const position =
-		user.getPerpPosition(order.marketIndex) ||
-		user.getEmptyPosition(order.marketIndex);
-
-	// if no position exists, it's risk increasing
-	if (position.baseAssetAmount.eq(ZERO)) {
-		return true;
-	}
-
-	// if position is long and order is long
-	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
-		return true;
-	}
-
-	// if position is short and order is short
-	if (
-		position.baseAssetAmount.lt(ZERO) &&
-		isVariant(order.direction, 'short')
-	) {
-		return true;
-	}
-
-	const baseAssetAmountToFill = order.baseAssetAmount.sub(
-		order.baseAssetAmountFilled
-	);
-	// if order will flip position
-	if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(TWO))) {
-		return true;
-	}
-
-	return false;
-}
-
-export function isOrderRiskIncreasingInSameDirection(
-	user: User,
-	order: Order
-): boolean {
-	if (!isVariant(order.status, 'open')) {
-		return false;
-	}
-
-	const position =
-		user.getPerpPosition(order.marketIndex) ||
-		user.getEmptyPosition(order.marketIndex);
-
-	// if no position exists, it's risk increasing
-	if (position.baseAssetAmount.eq(ZERO)) {
-		return true;
-	}
-
-	// if position is long and order is long
-	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
-		return true;
-	}
-
-	// if position is short and order is short
-	if (
-		position.baseAssetAmount.lt(ZERO) &&
-		isVariant(order.direction, 'short')
-	) {
-		return true;
-	}
-
-	return false;
-}
-
-export function isOrderReduceOnly(user: User, order: Order): boolean {
-	if (!isVariant(order.status, 'open')) {
-		return false;
-	}
-
-	const position =
-		user.getPerpPosition(order.marketIndex) ||
-		user.getEmptyPosition(order.marketIndex);
-
-	// if position is long and order is long
-	if (
-		position.baseAssetAmount.gte(ZERO) &&
-		isVariant(order.direction, 'long')
-	) {
-		return false;
-	}
-
-	// if position is short and order is short
-	if (
-		position.baseAssetAmount.lte(ZERO) &&
-		isVariant(order.direction, 'short')
-	) {
-		return false;
-	}
-
-	return true;
-}
-
 export function standardizeBaseAssetAmount(
 	baseAssetAmount: BN,
 	stepSize: BN
@@ -252,11 +151,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 	const limitPrice = getLimitPrice(order, mmOraclePriceData, slot);
 	let baseAssetAmount;
 
-	const updatedAMM = calculateUpdatedAMM(
-		market.amm,
-		market.totalExchangeFee,
-		mmOraclePriceData
-	);
+	const updatedAMM = calculateUpdatedAMM(market.amm, mmOraclePriceData);
 	if (limitPrice !== undefined) {
 		baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
 			order,
@@ -381,10 +276,6 @@ export function isRestingLimitOrder(order: Order, slot: number): boolean {
 	return order.postOnly || isAuctionComplete(order, slot);
 }
 
-export function isTakingOrder(order: Order, slot: number): boolean {
-	return isMarketOrder(order) || !isRestingLimitOrder(order, slot);
-}
-
 const FLAG_IS_SIGNED_MSG = 0x01;
 export function isSignedMsgOrder(order: Order): boolean {
 	return (order.bitFlags & FLAG_IS_SIGNED_MSG) !== 0;

package/src/math/position.ts

@@ -54,7 +54,6 @@ export function calculateBaseAssetValue(
 				calculateUpdatedAMMSpreadReserves(
 					market.amm,
 					market.marketStats,
-					market.totalExchangeFee,
 					directionToClose,
 					mmOraclePriceData,
 					latestSlot
@@ -66,11 +65,7 @@ export function calculateBaseAssetValue(
 				pegMultiplier: newPeg,
 			};
 		} else {
-			prepegAmm = calculateUpdatedAMM(
-				market.amm,
-				market.totalExchangeFee,
-				mmOraclePriceData
-			);
+			prepegAmm = calculateUpdatedAMM(market.amm, mmOraclePriceData);
 		}
 	} else {
 		prepegAmm = market.amm;
@@ -96,6 +91,9 @@ export function calculateBaseAssetValue(
 				.mul(prepegAmm.pegMultiplier)
 				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
 				.add(ONE);
+
+		default:
+			throw new Error('Invalid position direction to close');
 	}
 }
 
@@ -234,16 +232,6 @@ export function calculateUnsettledFundingPnl(
 	return perPositionFundingRate;
 }
 
-/**
- * @deprecated use calculateUnsettledFundingPnl or calculateFeesAndFundingPnl instead
- */
-export function calculatePositionFundingPNL(
-	market: PerpMarketAccount,
-	perpPosition: PerpPosition
-): BN {
-	return calculateUnsettledFundingPnl(market, perpPosition);
-}
-
 export function positionIsAvailable(position: PerpPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&

package/src/math/repeg.ts

@@ -148,35 +148,6 @@ export function calculateBudgetedKBN(
 	return [numerator, denominator];
 }
 
-export function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN] {
-	// wolframalpha.com
-	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
-	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
-
-	// numer
-	//   =  y*d*d*Q - Cxd - Cdd
-	//   =  y/x*Q*d*d - Cd - Cd/x
-	//   = mark      - C/d - C/(x)
-	//   =  mark/C    - 1/d - 1/x
-
-	// denom
-	// = C*x*x + C*x*d + y*d*d*Q
-	// = x/d**2 + 1 / d + mark/C
-
-	// todo: assumes k = x * y
-	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-
-	const x = amm.baseAssetReserve;
-	const y = amm.quoteAssetReserve;
-
-	const d = amm.baseAssetAmountWithAmm;
-	const Q = amm.pegMultiplier;
-
-	const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
-
-	return [numerator, denominator];
-}
-
 export function calculateBudgetedPeg(
 	amm: AMM,
 	budget: BN,

package/src/math/spotBalance.ts

@@ -153,7 +153,7 @@ export function calculateAssetWeight(
 	balanceAmount: BN,
 	oraclePrice: BN,
 	spotMarket: SpotMarketAccount,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory | undefined
 ): BN {
 	const sizePrecision = TEN.pow(new BN(spotMarket.decimals));
 	let sizeInAmmReservePrecision;
@@ -221,7 +221,7 @@ export function calculateScaledInitialAssetWeight(
 export function calculateLiabilityWeight(
 	size: BN,
 	spotMarket: SpotMarketAccount,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory | undefined
 ): BN {
 	const sizePrecision = TEN.pow(new BN(spotMarket.decimals));
 	let sizeInAmmReservePrecision;
@@ -380,10 +380,10 @@ export function calculateSpotMarketBorrowCapacity(
 export function calculateInterestRate(
 	bank: SpotMarketAccount,
 	delta = ZERO,
-	currentUtilization: BN = null
+	currentUtilization?: BN
 ): BN {
 	// todo: ensure both a delta and current util aren't pass?
-	const utilization = currentUtilization || calculateUtilization(bank, delta);
+	const utilization = currentUtilization ?? calculateUtilization(bank, delta);
 
 	const optimalUtil = new BN(bank.optimalUtilization);
 	const optimalRate = new BN(bank.optimalBorrowRate);
@@ -442,15 +442,19 @@ export function calculateInterestRate(
 export function calculateDepositRate(
 	bank: SpotMarketAccount,
 	delta = ZERO,
-	currentUtilization: BN = null
+	currentUtilization?: BN
 ): BN {
 	// positive delta => adding to deposit
 	// negative delta => adding to borrow
 
-	const utilization = currentUtilization || calculateUtilization(bank, delta);
+	const utilization = currentUtilization ?? calculateUtilization(bank, delta);
 	const borrowRate = calculateBorrowRate(bank, delta, utilization);
 	const depositRate = borrowRate
-		.mul(PERCENTAGE_PRECISION.sub(new BN(bank.insuranceFund.totalFactor)))
+		.mul(
+			PERCENTAGE_PRECISION.sub(
+				new BN(bank.insuranceFund.ifFeeFactor + bank.protocolFeeFactor)
+			)
+		)
 		.mul(utilization)
 		.div(SPOT_MARKET_UTILIZATION_PRECISION)
 		.div(PERCENTAGE_PRECISION);
@@ -460,7 +464,7 @@ export function calculateDepositRate(
 export function calculateBorrowRate(
 	bank: SpotMarketAccount,
 	delta = ZERO,
-	currentUtilization: BN = null
+	currentUtilization?: BN
 ): BN {
 	return calculateInterestRate(bank, delta, currentUtilization);
 }
@@ -549,8 +553,8 @@ export function calculateWithdrawLimit(
 	withdrawLimit: BN;
 	minDepositAmount: BN;
 	maxBorrowAmount: BN;
-	currentDepositAmount;
-	currentBorrowAmount;
+	currentDepositAmount: BN;
+	currentBorrowAmount: BN;
 } {
 	const marketDepositTokenAmount = getTokenAmount(
 		spotMarket.depositBalance,

package/src/math/spotMarket.ts

@@ -5,12 +5,8 @@ import {
 	SpotBalanceType,
 	SpotMarketAccount,
 } from '../types';
-import {
-	calculateAssetWeight,
-	calculateLiabilityWeight,
-	getTokenAmount,
-} from './spotBalance';
-import { MARGIN_PRECISION, ZERO } from '../constants/numericConstants';
+import { calculateAssetWeight, calculateLiabilityWeight } from './spotBalance';
+import { MARGIN_PRECISION } from '../constants/numericConstants';
 import { numberToSafeBN } from './utils';
 
 export function castNumberToSpotPrecision(
@@ -58,25 +54,3 @@ export function calculateSpotMarketMarginRatio(
 
 	return marginRatio;
 }
-
-/**
- * Returns the maximum remaining deposit that can be made to the spot market. If the maxTokenDeposits on the market is zero then there is no limit and this function will also return zero. (so that needs to be checked)
- * @param market
- * @returns
- */
-export function calculateMaxRemainingDeposit(market: SpotMarketAccount) {
-	const marketMaxTokenDeposits = market.maxTokenDeposits;
-
-	if (marketMaxTokenDeposits.eq(ZERO)) {
-		// If the maxTokenDeposits is set to zero then that means there is no limit. Return the largest number we can to represent infinite available deposit.
-		return ZERO;
-	}
-
-	const totalDepositsTokenAmount = getTokenAmount(
-		market.depositBalance,
-		market,
-		SpotBalanceType.DEPOSIT
-	);
-
-	return marketMaxTokenDeposits.sub(totalDepositsTokenAmount);
-}