@drift-labs/sdk 2.34.1-beta.2 → 2.34.1-beta.3

package/src/math/funding.ts

@@ -4,10 +4,107 @@ import {
 	PRICE_PRECISION,
 	QUOTE_PRECISION,
 	ZERO,
+	ONE,
 } from '../constants/numericConstants';
 import { PerpMarketAccount, isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import { calculateBidAskPrice } from './amm';
+import { calculateLiveOracleTwap } from './oracles';
+
+function calculateLiveMarkTwap(
+	market: PerpMarketAccount,
+	oraclePriceData?: OraclePriceData,
+	markPrice?: BN,
+	now?: BN,
+	period = new BN(3600)
+): BN {
+	now = now || new BN((Date.now() / 1000).toFixed(0));
+
+	const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
+	const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
+
+	const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
+	const markTwapTimeSinceLastUpdate = BN.max(
+		period,
+		BN.max(ZERO, period.sub(timeSinceLastMarkChange))
+	);
+
+	if (!markPrice) {
+		const [bid, ask] = calculateBidAskPrice(market.amm, oraclePriceData);
+		markPrice = bid.add(ask).div(new BN(2));
+	}
+
+	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
+		.mul(lastMarkTwapWithMantissa)
+		.add(timeSinceLastMarkChange.mul(markPrice))
+		.div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
+
+	return markTwapWithMantissa;
+}
+
+function shrinkStaleTwaps(
+	market: PerpMarketAccount,
+	markTwapWithMantissa: BN,
+	oracleTwapWithMantissa: BN,
+	now?: BN
+) {
+	now = now || new BN((Date.now() / 1000).toFixed(0));
+	let newMarkTwap = markTwapWithMantissa;
+	let newOracleTwap = oracleTwapWithMantissa;
+	if (
+		market.amm.lastMarkPriceTwapTs.gt(
+			market.amm.historicalOracleData.lastOraclePriceTwapTs
+		)
+	) {
+		// shrink oracle based on invalid intervals
+		const oracleInvalidDuration = BN.max(
+			ZERO,
+			market.amm.lastMarkPriceTwapTs.sub(
+				market.amm.historicalOracleData.lastOraclePriceTwapTs
+			)
+		);
+		const timeSinceLastOracleTwapUpdate = now.sub(
+			market.amm.historicalOracleData.lastOraclePriceTwapTs
+		);
+		const oracleTwapTimeSinceLastUpdate = BN.max(
+			ONE,
+			BN.min(
+				market.amm.fundingPeriod,
+				BN.max(ONE, market.amm.fundingPeriod.sub(timeSinceLastOracleTwapUpdate))
+			)
+		);
+		newOracleTwap = oracleTwapTimeSinceLastUpdate
+			.mul(oracleTwapWithMantissa)
+			.add(oracleInvalidDuration.mul(markTwapWithMantissa))
+			.div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
+	} else if (
+		market.amm.lastMarkPriceTwapTs.lt(
+			market.amm.historicalOracleData.lastOraclePriceTwapTs
+		)
+	) {
+		// shrink mark to oracle twap over tradless intervals
+		const tradelessDuration = BN.max(
+			ZERO,
+			market.amm.historicalOracleData.lastOraclePriceTwapTs.sub(
+				market.amm.lastMarkPriceTwapTs
+			)
+		);
+		const timeSinceLastMarkTwapUpdate = now.sub(market.amm.lastMarkPriceTwapTs);
+		const markTwapTimeSinceLastUpdate = BN.max(
+			ONE,
+			BN.min(
+				market.amm.fundingPeriod,
+				BN.max(ONE, market.amm.fundingPeriod.sub(timeSinceLastMarkTwapUpdate))
+			)
+		);
+		newMarkTwap = markTwapTimeSinceLastUpdate
+			.mul(markTwapWithMantissa)
+			.add(tradelessDuration.mul(oracleTwapWithMantissa))
+			.div(markTwapTimeSinceLastUpdate.add(tradelessDuration));
+	}
+
+	return [newMarkTwap, newOracleTwap];
+}
 
 /**
  *
@@ -19,110 +116,65 @@ import { calculateBidAskPrice } from './amm';
 export async function calculateAllEstimatedFundingRate(
 	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
-	periodAdjustment: BN = new BN(1),
+	markPrice?: BN,
 	now?: BN
 ): Promise<[BN, BN, BN, BN, BN]> {
-	// periodAdjustment
-	// 	1: hourly
-	//  24: daily
-	//  24 * 365.25: annualized
-	const secondsInHour = new BN(3600);
-	const hoursInDay = new BN(24);
-	const ONE = new BN(1);
-
 	if (isVariant(market.status, 'uninitialized')) {
 		return [ZERO, ZERO, ZERO, ZERO, ZERO];
 	}
 
-	const payFreq = new BN(market.amm.fundingPeriod);
-
 	// todo: sufficiently differs from blockchain timestamp?
 	now = now || new BN((Date.now() / 1000).toFixed(0));
-	const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
 
-	// calculate real-time mark twap
-	const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
-	const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
-
-	const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
-	const markTwapTimeSinceLastUpdate = BN.max(
-		secondsInHour,
-		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
+	// calculate real-time mark and oracle twap
+	const liveMarkTwap = calculateLiveMarkTwap(
+		market,
+		oraclePriceData,
+		markPrice,
+		now,
+		market.amm.fundingPeriod
 	);
-	const [bid, ask] = calculateBidAskPrice(market.amm, oraclePriceData);
-	const baseAssetPriceWithMantissa = bid.add(ask).div(new BN(2));
-
-	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
-		.mul(lastMarkTwapWithMantissa)
-		.add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))
-		.div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
-
-	// calculate real-time (predicted) oracle twap
-	// note: oracle twap depends on `when the chord is struck` (market is trade)
-	const lastOracleTwapWithMantissa =
-		market.amm.historicalOracleData.lastOraclePriceTwap;
-	const lastOraclePriceTwapTs =
-		market.amm.historicalOracleData.lastOraclePriceTwapTs;
-
-	const oracleInvalidDuration = BN.max(
-		ZERO,
-		lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs)
+	const liveOracleTwap = calculateLiveOracleTwap(
+		market.amm.historicalOracleData,
+		oraclePriceData,
+		now,
+		market.amm.fundingPeriod
 	);
-
-	const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
-	const oracleTwapTimeSinceLastUpdate = BN.max(
-		ONE,
-		BN.min(
-			secondsInHour,
-			BN.max(ONE, secondsInHour.sub(timeSinceLastOracleTwapUpdate))
-		)
+	const [markTwap, oracleTwap] = shrinkStaleTwaps(
+		market,
+		liveMarkTwap,
+		liveOracleTwap,
+		now
 	);
-	let oracleTwapWithMantissa = lastOracleTwapWithMantissa;
-
-	// if passing live oracle data, improve predicted calc estimate
-	if (oraclePriceData) {
-		const oraclePrice = oraclePriceData.price;
 
-		const oracleLiveVsTwap = oraclePrice
-			.sub(lastOracleTwapWithMantissa)
-			.abs()
-			.mul(PRICE_PRECISION)
-			.mul(new BN(100))
-			.div(lastOracleTwapWithMantissa);
+	// if(!markTwap.eq(liveMarkTwap)){
+	// 	console.log('shrink mark:', liveMarkTwap.toString(), '->', markTwap.toString());
+	// }
 
-		// verify pyth live input is within 20% of last twap for live update
-		if (oracleLiveVsTwap.lte(PRICE_PRECISION.mul(new BN(20)))) {
-			oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
-				.mul(lastOracleTwapWithMantissa)
-				.add(timeSinceLastMarkChange.mul(oraclePrice))
-				.div(timeSinceLastMarkChange.add(oracleTwapTimeSinceLastUpdate));
-		}
-	}
-
-	const shrunkLastOracleTwapwithMantissa = oracleTwapTimeSinceLastUpdate
-		.mul(oracleTwapWithMantissa)
-		.add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
-		.div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
-
-	const twapSpread = markTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
+	// if(!oracleTwap.eq(liveOracleTwap)){
+	// 	console.log('shrink orac:', liveOracleTwap.toString(), '->', oracleTwap.toString());
+	// }
 
+	const twapSpread = markTwap.sub(oracleTwap);
 	const twapSpreadPct = twapSpread
 		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
-		.div(shrunkLastOracleTwapwithMantissa);
+		.div(oracleTwap);
+
+	const secondsInHour = new BN(3600);
+	const hoursInDay = new BN(24);
+	const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
 
 	const lowerboundEst = twapSpreadPct
-		.mul(payFreq)
+		.mul(market.amm.fundingPeriod)
 		.mul(BN.min(secondsInHour, timeSinceLastUpdate))
-		.mul(periodAdjustment)
 		.div(secondsInHour)
 		.div(secondsInHour)
 		.div(hoursInDay);
 
-	const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+	const interpEst = twapSpreadPct.div(hoursInDay);
 
 	const interpRateQuote = twapSpreadPct
-		.mul(periodAdjustment)
 		.div(hoursInDay)
 		.div(PRICE_PRECISION.div(QUOTE_PRECISION));
 
@@ -140,13 +192,7 @@ export async function calculateAllEstimatedFundingRate(
 		largerSide = market.amm.baseAssetAmountLong.abs();
 		smallerSide = market.amm.baseAssetAmountShort.abs();
 		if (twapSpread.gt(new BN(0))) {
-			return [
-				markTwapWithMantissa,
-				oracleTwapWithMantissa,
-				lowerboundEst,
-				interpEst,
-				interpEst,
-			];
+			return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
 		}
 	} else if (
 		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
@@ -154,22 +200,10 @@ export async function calculateAllEstimatedFundingRate(
 		largerSide = market.amm.baseAssetAmountShort.abs();
 		smallerSide = market.amm.baseAssetAmountLong.abs();
 		if (twapSpread.lt(new BN(0))) {
-			return [
-				markTwapWithMantissa,
-				oracleTwapWithMantissa,
-				lowerboundEst,
-				interpEst,
-				interpEst,
-			];
+			return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
 		}
 	} else {
-		return [
-			markTwapWithMantissa,
-			oracleTwapWithMantissa,
-			lowerboundEst,
-			interpEst,
-			interpEst,
-		];
+		return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
 	}
 
 	if (largerSide.gt(ZERO)) {
@@ -183,8 +217,7 @@ export async function calculateAllEstimatedFundingRate(
 		cappedAltEst = cappedAltEst
 			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
-			.div(oracleTwapWithMantissa)
-			.mul(periodAdjustment);
+			.div(oracleTwap);
 
 		if (cappedAltEst.abs().gte(interpEst.abs())) {
 			cappedAltEst = interpEst;
@@ -193,44 +226,7 @@ export async function calculateAllEstimatedFundingRate(
 		cappedAltEst = interpEst;
 	}
 
-	return [
-		markTwapWithMantissa,
-		oracleTwapWithMantissa,
-		lowerboundEst,
-		cappedAltEst,
-		interpEst,
-	];
-}
-
-/**
- *
- * @param market
- * @param oraclePriceData
- * @param periodAdjustment
- * @param estimationMethod
- * @returns Estimated funding rate. : Precision //TODO-PRECISION
- */
-export async function calculateEstimatedFundingRate(
-	market: PerpMarketAccount,
-	oraclePriceData?: OraclePriceData,
-	periodAdjustment: BN = new BN(1),
-	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
-): Promise<BN> {
-	const [_1, _2, lowerboundEst, cappedAltEst, interpEst] =
-		await calculateAllEstimatedFundingRate(
-			market,
-			oraclePriceData,
-			periodAdjustment
-		);
-
-	if (estimationMethod == 'lowerbound') {
-		//assuming remaining funding period has no gap
-		return lowerboundEst;
-	} else if (estimationMethod == 'capped') {
-		return cappedAltEst;
-	} else {
-		return interpEst;
-	}
+	return [markTwap, oracleTwap, lowerboundEst, cappedAltEst, interpEst];
 }
 
 /**
@@ -243,13 +239,15 @@ export async function calculateEstimatedFundingRate(
 export async function calculateLongShortFundingRate(
 	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
-	periodAdjustment: BN = new BN(1)
+	markPrice?: BN,
+	now?: BN
 ): Promise<[BN, BN]> {
 	const [_1, _2, _, cappedAltEst, interpEst] =
 		await calculateAllEstimatedFundingRate(
 			market,
 			oraclePriceData,
-			periodAdjustment
+			markPrice,
+			now
 		);
 
 	if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
@@ -273,13 +271,15 @@ export async function calculateLongShortFundingRate(
 export async function calculateLongShortFundingRateAndLiveTwaps(
 	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
-	periodAdjustment: BN = new BN(1)
+	markPrice?: BN,
+	now?: BN
 ): Promise<[BN, BN, BN, BN]> {
 	const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] =
 		await calculateAllEstimatedFundingRate(
 			market,
 			oraclePriceData,
-			periodAdjustment
+			markPrice,
+			now
 		);
 
 	if (

package/src/user.ts

@@ -1442,14 +1442,17 @@ export class User {
 
 	/**
 	 * calculates max allowable leverage exceeding hitting requirement category
+	 * for large sizes where imf factor activates, result is a lower bound
 	 * @params category {Initial, Maintenance}
 	 * @returns : Precision TEN_THOUSAND
 	 */
 	public getMaxLeverageForPerp(
 		perpMarketIndex: number,
-		category: MarginCategory = 'Initial'
+		marginCategory: MarginCategory = 'Initial'
 	): BN {
 		const market = this.driftClient.getPerpMarketAccount(perpMarketIndex);
+		const marketPrice =
+			this.driftClient.getOracleDataForPerpMarket(perpMarketIndex).price;
 
 		const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } =
 			this.getLeverageComponents();
@@ -1464,13 +1467,61 @@ export class User {
 
 		const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
 
-		const marginRatio = calculateMarketMarginRatio(
-			market,
-			ZERO, // todo
-			category
-		);
 		const freeCollateral = this.getFreeCollateral();
 
+		let rawMarginRatio;
+
+		switch (marginCategory) {
+			case 'Initial':
+				rawMarginRatio = market.marginRatioInitial;
+				break;
+			case 'Maintenance':
+				rawMarginRatio = market.marginRatioMaintenance;
+				break;
+			default:
+				rawMarginRatio = market.marginRatioInitial;
+				break;
+		}
+
+		// absolute max fesible size (upper bound)
+		const maxSize = BN.max(
+			ZERO,
+			freeCollateral
+				.mul(MARGIN_PRECISION)
+				.div(new BN(rawMarginRatio))
+				.mul(PRICE_PRECISION)
+				.div(marketPrice)
+		);
+
+		// margin ratio incorporting upper bound on size
+		let marginRatio = calculateMarketMarginRatio(
+			market,
+			maxSize,
+			marginCategory
+		);
+
+		// use more fesible size since imf factor activated
+		let attempts = 0;
+		while (marginRatio > rawMarginRatio + 1e-4 && attempts < 10) {
+			// more fesible size (upper bound)
+			const targetSize = BN.max(
+				ZERO,
+				freeCollateral
+					.mul(MARGIN_PRECISION)
+					.div(new BN(marginRatio))
+					.mul(PRICE_PRECISION)
+					.div(marketPrice)
+			);
+
+			// margin ratio incorporting more fesible target size
+			marginRatio = calculateMarketMarginRatio(
+				market,
+				targetSize,
+				marginCategory
+			);
+			attempts += 1;
+		}
+
 		// how much more liabilities can be opened w remaining free collateral
 		const additionalLiabilities = freeCollateral
 			.mul(MARGIN_PRECISION)

package/tests/amm/test.ts

@@ -10,10 +10,14 @@ import {
 	calculateLiveOracleStd,
 	calculateLiveOracleTwap,
 	calculateInventoryScale,
+	calculateAllEstimatedFundingRate,
+	calculateLongShortFundingRateAndLiveTwaps,
+	OraclePriceData
 } from '../../src';
 import { mockPerpMarkets } from '../dlob/helpers';
 
 import { assert } from '../../src/assert/assert';
+import * as _ from 'lodash';
 
 class AMMSpreadTerms {
 	longVolSpread: number;
@@ -386,4 +390,122 @@ describe('AMM Tests', () => {
 		console.log('liveOracleStd:', liveOracleStd.toNumber());
 		assert(liveOracleStd.eq(new BN(192962)));
 	});
+
+	it('predicted funding rate mock1', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+
+		// make it like RNDR
+		const now = new BN(1688878353);
+
+		mockMarket1.amm.fundingPeriod = new BN(3600);
+		mockMarket1.amm.lastFundingRateTs = new BN(1688860817);
+
+		const currentMarkPrice = new BN(1.9843 * PRICE_PRECISION.toNumber()); // trading at a premium
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(1.9535 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(1.9535 * PRICE_PRECISION.toNumber());
+
+		// mockMarket1.amm.pegMultiplier = new BN(1.897573 * 1e3);
+
+		mockMarket1.amm.lastMarkPriceTwap = new BN(1.945594 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.lastBidPriceTwap = new BN(1.941629 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.lastAskPriceTwap = new BN(1.94956 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.lastMarkPriceTwapTs = new BN(1688877729);
+
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwap = new BN(1.942449 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwapTs = new BN(1688878333);
+
+		const [_markTwapLive, _oracleTwapLive, _lowerboundEst, _cappedAltEst, _interpEst] =
+			await calculateAllEstimatedFundingRate(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		const [markTwapLive, oracleTwapLive, est1, est2] = await calculateLongShortFundingRateAndLiveTwaps(
+			mockMarket1,
+			oraclePriceData,
+			currentMarkPrice,
+			now
+		);
+
+		// console.log(markTwapLive.toString());
+		// console.log(oracleTwapLive.toString());
+		// console.log(est1.toString());
+		// console.log(est2.toString());
+
+		assert(markTwapLive.eq(new BN('1949826')));
+		assert(oracleTwapLive.eq(new BN('1942510')));
+		assert(est1.eq(new BN('15692')));
+		assert(est2.eq(new BN('15692')));
+
+	});
+
+	it('predicted funding rate mock2', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+
+		// make it like OP
+		const now = new BN(1688881915);
+
+		mockMarket1.amm.fundingPeriod = new BN(3600);
+		mockMarket1.amm.lastFundingRateTs = new BN(1688864415);
+
+		const currentMarkPrice = new BN(1.2242 * PRICE_PRECISION.toNumber()); // trading at a premium
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(1.224 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(1.9535 * PRICE_PRECISION.toNumber());
+
+		// mockMarket1.amm.pegMultiplier = new BN(1.897573 * 1e3);
+
+		mockMarket1.amm.lastMarkPriceTwap = new BN(1.218363 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.lastBidPriceTwap = new BN(1.218363 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.lastAskPriceTwap = new BN(1.218364 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.lastMarkPriceTwapTs = new BN(1688878815);
+
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwap = new BN(1.220964 * PRICE_PRECISION.toNumber());
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwapTs = new BN(1688879991);
+
+		const [_markTwapLive, _oracleTwapLive, _lowerboundEst, _cappedAltEst, _interpEst] =
+			await calculateAllEstimatedFundingRate(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		// console.log(_markTwapLive.toString());
+		// console.log(_oracleTwapLive.toString());
+		// console.log(_lowerboundEst.toString());
+		// console.log(_cappedAltEst.toString());
+		// console.log(_interpEst.toString());
+		// console.log('-----');
+
+		const [markTwapLive, oracleTwapLive, est1, est2] = await calculateLongShortFundingRateAndLiveTwaps(
+			mockMarket1,
+			oraclePriceData,
+			currentMarkPrice,
+			now
+		);
+
+		console.log('markTwapLive:', mockMarket1.amm.lastMarkPriceTwap.toString(), '->', markTwapLive.toString());
+		console.log('oracTwapLive:', mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(), '->', oracleTwapLive.toString());
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1222131')));
+		assert(oracleTwapLive.eq(new BN('1222586')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-1550')));
+
+	});
 });

package/tests/dlob/helpers.ts

@@ -21,6 +21,7 @@ import {
 	OrderRecord,
 	ZERO,
 	ContractTier,
+	SPOT_MARKET_BALANCE_PRECISION,
 } from '../../src';
 
 export const mockPerpPosition: PerpPosition = {
@@ -151,8 +152,8 @@ export const mockPerpMarkets: Array<PerpMarketAccount> = [
 		amm: mockAMM,
 		numberOfUsersWithBase: 0,
 		numberOfUsers: 0,
-		marginRatioInitial: 0,
-		marginRatioMaintenance: 0,
+		marginRatioInitial: 2000,
+		marginRatioMaintenance: 1000,
 		nextFillRecordId: new BN(0),
 		pnlPool: {
 			scaledBalance: new BN(0),
@@ -257,7 +258,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		status: MarketStatus.ACTIVE,
 		assetTier: AssetTier.COLLATERAL,
 		name: [],
-		maxTokenDeposits: new BN(100),
+		maxTokenDeposits: new BN(1000000),
 		marketIndex: 0,
 		pubkey: PublicKey.default,
 		mint: DevnetSpotMarkets[0].mint,
@@ -285,8 +286,8 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 		optimalUtilization: 0,
 		optimalBorrowRate: 0,
 		maxBorrowRate: 0,
-		cumulativeDepositInterest: new BN(0),
-		cumulativeBorrowInterest: new BN(0),
+		cumulativeDepositInterest: SPOT_MARKET_BALANCE_PRECISION,
+		cumulativeBorrowInterest: SPOT_MARKET_BALANCE_PRECISION,
 		totalSocialLoss: new BN(0),
 		totalQuoteSocialLoss: new BN(0),
 		depositBalance: new BN(0),