@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/src/math/funding.ts

@@ -1,13 +1,13 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_RESERVE_PRECISION,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { MarketAccount } from '../types';
-import { calculateMarkPrice } from './market';
+import { PerpMarketAccount, isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
+import { calculateBidAskPrice } from './amm';
 
 /**
  *
@@ -17,7 +17,7 @@ import { OraclePriceData } from '../oracles/types';
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateAllEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
@@ -29,7 +29,7 @@ export async function calculateAllEstimatedFundingRate(
 	const hoursInDay = new BN(24);
 	const ONE = new BN(1);
 
-	if (!market.initialized) {
+	if (isVariant(market.status, 'uninitialized')) {
 		return [ZERO, ZERO, ZERO, ZERO, ZERO];
 	}
 
@@ -48,10 +48,8 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
-	const baseAssetPriceWithMantissa = calculateMarkPrice(
-		market,
-		oraclePriceData
-	);
+	const [bid, ask] = calculateBidAskPrice(market.amm, oraclePriceData);
+	const baseAssetPriceWithMantissa = bid.add(ask).div(new BN(2));
 
 	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
 		.mul(lastMarkTwapWithMantissa)
@@ -60,8 +58,10 @@ export async function calculateAllEstimatedFundingRate(
 
 	// calculate real-time (predicted) oracle twap
 	// note: oracle twap depends on `when the chord is struck` (market is trade)
-	const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
-	const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+	const lastOracleTwapWithMantissa =
+		market.amm.historicalOracleData.lastOraclePriceTwap;
+	const lastOraclePriceTwapTs =
+		market.amm.historicalOracleData.lastOraclePriceTwapTs;
 
 	const oracleInvalidDuration = BN.max(
 		ZERO,
@@ -85,12 +85,12 @@ export async function calculateAllEstimatedFundingRate(
 		const oracleLiveVsTwap = oraclePrice
 			.sub(lastOracleTwapWithMantissa)
 			.abs()
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(lastOracleTwapWithMantissa);
 
 		// verify pyth live input is within 10% of last twap for live update
-		if (oracleLiveVsTwap.lte(MARK_PRICE_PRECISION.mul(new BN(10)))) {
+		if (oracleLiveVsTwap.lte(PRICE_PRECISION.mul(new BN(10)))) {
 			oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
 				.mul(lastOracleTwapWithMantissa)
 				.add(timeSinceLastMarkChange.mul(oraclePrice))
@@ -108,7 +108,7 @@ export async function calculateAllEstimatedFundingRate(
 	);
 
 	const twapSpreadPct = twapSpread
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
 		.div(shrunkLastOracleTwapwithMantissa);
 
@@ -125,7 +125,7 @@ export async function calculateAllEstimatedFundingRate(
 	const interpRateQuote = twapSpreadPct
 		.mul(periodAdjustment)
 		.div(hoursInDay)
-		.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
+		.div(PRICE_PRECISION.div(QUOTE_PRECISION));
 
 	let feePoolSize = calculateFundingPool(market);
 	if (interpRateQuote.lt(new BN(0))) {
@@ -135,9 +135,11 @@ export async function calculateAllEstimatedFundingRate(
 	let cappedAltEst: BN;
 	let largerSide: BN;
 	let smallerSide: BN;
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-		largerSide = market.baseAssetAmountLong.abs();
-		smallerSide = market.baseAssetAmountShort.abs();
+	if (
+		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
+	) {
+		largerSide = market.amm.baseAssetAmountLong.abs();
+		smallerSide = market.amm.baseAssetAmountShort.abs();
 		if (twapSpread.gt(new BN(0))) {
 			return [
 				markTwapWithMantissa,
@@ -147,9 +149,11 @@ export async function calculateAllEstimatedFundingRate(
 				interpEst,
 			];
 		}
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
-		largerSide = market.baseAssetAmountShort.abs();
-		smallerSide = market.baseAssetAmountLong.abs();
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
+	) {
+		largerSide = market.amm.baseAssetAmountShort.abs();
+		smallerSide = market.amm.baseAssetAmountLong.abs();
 		if (twapSpread.lt(new BN(0))) {
 			return [
 				markTwapWithMantissa,
@@ -173,12 +177,12 @@ export async function calculateAllEstimatedFundingRate(
 		// funding smaller flow
 		cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
 		const feePoolTopOff = feePoolSize
-			.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
+			.mul(PRICE_PRECISION.div(QUOTE_PRECISION))
 			.mul(AMM_RESERVE_PRECISION);
 		cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
 
 		cappedAltEst = cappedAltEst
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(oracleTwapWithMantissa)
 			.mul(periodAdjustment);
@@ -208,7 +212,7 @@ export async function calculateAllEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
@@ -238,7 +242,7 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
@@ -249,9 +253,11 @@ export async function calculateLongShortFundingRate(
 			periodAdjustment
 		);
 
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+	if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
 		return [cappedAltEst, interpEst];
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)
+	) {
 		return [interpEst, cappedAltEst];
 	} else {
 		return [interpEst, interpEst];
@@ -266,7 +272,7 @@ export async function calculateLongShortFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
@@ -277,9 +283,13 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
 			periodAdjustment
 		);
 
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+	if (
+		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
+	) {
 		return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
+	) {
 		return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
 	} else {
 		return [markTwapLive, oracleTwapLive, interpEst, interpEst];
@@ -291,7 +301,7 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
  * @param market
  * @returns Estimated fee pool size
  */
-export function calculateFundingPool(market: MarketAccount): BN {
+export function calculateFundingPool(market: PerpMarketAccount): BN {
 	// todo
 	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
 	const feePool = BN.max(

package/src/math/insurance.ts

@@ -0,0 +1,35 @@
+import { ZERO } from '../constants/numericConstants';
+import { BN } from '../index';
+
+export function stakeAmountToShares(
+	amount: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let nShares: BN;
+	if (insuranceFundVaultBalance.gt(ZERO)) {
+		nShares = amount.mul(totalIfShares).div(insuranceFundVaultBalance);
+	} else {
+		nShares = amount;
+	}
+
+	return nShares;
+}
+
+export function unstakeSharesToAmount(
+	nShares: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let amount: BN;
+	if (totalIfShares.gt(ZERO)) {
+		amount = BN.max(
+			ZERO,
+			nShares.mul(insuranceFundVaultBalance).div(totalIfShares)
+		);
+	} else {
+		amount = ZERO;
+	}
+
+	return amount;
+}

package/src/math/margin.ts

@@ -0,0 +1,133 @@
+import { squareRootBN } from './utils';
+import {
+	SPOT_MARKET_WEIGHT_PRECISION,
+	SPOT_MARKET_IMF_PRECISION,
+	ZERO,
+	BID_ASK_SPREAD_PRECISION,
+	AMM_RESERVE_PRECISION,
+} from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { PerpMarketAccount, PerpPosition } from '..';
+import { isVariant } from '../types';
+import { assert } from '../assert/assert';
+
+export function calculateSizePremiumLiabilityWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	liabilityWeight: BN,
+	precision: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return liabilityWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+
+	const denom0 = BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor));
+	assert(denom0.gt(ZERO));
+	const liabilityWeightNumerator = liabilityWeight.sub(
+		liabilityWeight.div(
+			BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor))
+		)
+	);
+
+	const denom = new BN(100_000).mul(SPOT_MARKET_IMF_PRECISION).div(precision);
+	assert(denom.gt(ZERO));
+
+	const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(
+		sizeSqrt // 1e5
+			.mul(imfFactor)
+			.div(denom) // 1e5
+	);
+
+	const maxLiabilityWeight = BN.max(
+		liabilityWeight,
+		sizePremiumLiabilityWeight
+	);
+	return maxLiabilityWeight;
+}
+
+export function calculateSizeDiscountAssetWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	assetWeight: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return assetWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
+	const imfNumerator = SPOT_MARKET_IMF_PRECISION.add(
+		SPOT_MARKET_IMF_PRECISION.div(new BN(10))
+	);
+
+	const sizeDiscountAssetWeight = imfNumerator
+		.mul(SPOT_MARKET_WEIGHT_PRECISION)
+		.div(
+			SPOT_MARKET_IMF_PRECISION.add(
+				sizeSqrt // 1e5
+					.mul(imfFactor)
+					.div(new BN(100_000)) // 1e5
+			)
+		);
+
+	const minAssetWeight = BN.min(assetWeight, sizeDiscountAssetWeight);
+
+	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;
+}
+
+export function calculateBaseAssetValueWithOracle(
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	let price = oraclePriceData.price;
+	if (isVariant(market.status, 'settlement')) {
+		price = market.expiryPrice;
+	}
+
+	return perpPosition.baseAssetAmount
+		.abs()
+		.mul(price)
+		.div(AMM_RESERVE_PRECISION);
+}
+
+export function calculateWorstCaseBaseAssetAmount(
+	perpPosition: PerpPosition
+): BN {
+	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
+
+	if (allBids.abs().gt(allAsks.abs())) {
+		return allBids;
+	} else {
+		return allAsks;
+	}
+}

package/src/math/market.ts

@@ -1,5 +1,11 @@
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import {
+	PerpMarketAccount,
+	PositionDirection,
+	MarginCategory,
+	SpotMarketAccount,
+	SpotBalanceType,
+} from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -7,16 +13,27 @@ import {
 	getSwapDirection,
 	calculateUpdatedAMM,
 } from './amm';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 import { OraclePriceData } from '../oracles/types';
+import {
+	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_TO_QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { getTokenAmount } from './spotBalance';
 
 /**
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-export function calculateMarkPrice(
-	market: MarketAccount,
+export function calculateReservePrice(
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
@@ -31,10 +48,10 @@ export function calculateMarkPrice(
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
 export function calculateBidPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -51,10 +68,10 @@ export function calculateBidPrice(
  * Calculates market ask price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
 export function calculateAskPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -70,8 +87,8 @@ export function calculateAskPrice(
 export function calculateNewMarketAfterTrade(
 	baseAssetAmount: BN,
 	direction: PositionDirection,
-	market: MarketAccount
-): MarketAccount {
+	market: PerpMarketAccount
+): PerpMarketAccount {
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
@@ -89,12 +106,12 @@ export function calculateNewMarketAfterTrade(
 	return newMarket;
 }
 
-export function calculateMarkOracleSpread(
-	market: MarketAccount,
+export function calculateOracleReserveSpread(
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const markPrice = calculateMarkPrice(market, oraclePriceData);
-	return calculateOracleSpread(markPrice, oraclePriceData);
+	const reservePrice = calculateReservePrice(market, oraclePriceData);
+	return calculateOracleSpread(reservePrice, oraclePriceData);
 }
 
 export function calculateOracleSpread(
@@ -103,3 +120,115 @@ export function calculateOracleSpread(
 ): BN {
 	return price.sub(oraclePriceData.price);
 }
+
+export function calculateMarketMarginRatio(
+	market: PerpMarketAccount,
+	size: BN,
+	marginCategory: MarginCategory
+): number {
+	let marginRatio;
+	switch (marginCategory) {
+		case 'Initial':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				new BN(market.imfFactor),
+				new BN(market.marginRatioInitial),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+		case 'Maintenance':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				new BN(market.imfFactor),
+				new BN(market.marginRatioMaintenance),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+	}
+
+	return marginRatio;
+}
+
+export function calculateUnrealizedAssetWeight(
+	market: PerpMarketAccount,
+	quoteSpotMarket: SpotMarketAccount,
+	unrealizedPnl: BN,
+	marginCategory: MarginCategory,
+	oraclePriceData: OraclePriceData
+): BN {
+	let assetWeight: BN;
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = new BN(market.unrealizedPnlInitialAssetWeight);
+
+			if (market.unrealizedPnlMaxImbalance.gt(ZERO)) {
+				const netUnsettledPnl = calculateNetUserPnlImbalance(
+					market,
+					quoteSpotMarket,
+					oraclePriceData
+				);
+				if (netUnsettledPnl.gt(market.unrealizedPnlMaxImbalance)) {
+					assetWeight = assetWeight
+						.mul(market.unrealizedPnlMaxImbalance)
+						.div(netUnsettledPnl);
+				}
+			}
+
+			assetWeight = calculateSizeDiscountAssetWeight(
+				unrealizedPnl,
+				new BN(market.unrealizedPnlImfFactor),
+				assetWeight
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = new BN(market.unrealizedPnlMaintenanceAssetWeight);
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateMarketAvailablePNL(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount
+): BN {
+	return getTokenAmount(
+		perpMarket.pnlPool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+}
+
+export function calculateNetUserPnl(
+	perpMarket: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
+		.mul(oraclePriceData.price)
+		.div(BASE_PRECISION)
+		.div(PRICE_TO_QUOTE_PRECISION);
+
+	const netUserCostBasis = perpMarket.amm.quoteAssetAmount;
+
+	const netUserPnl = netUserPositionValue.add(netUserCostBasis);
+
+	return netUserPnl;
+}
+
+export function calculateNetUserPnlImbalance(
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
+
+	const pnlPool = getTokenAmount(
+		perpMarket.pnlPool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+
+	const imbalance = netUserPnl.sub(pnlPool);
+
+	return imbalance;
+}

package/src/math/oracles.ts

@@ -1,7 +1,29 @@
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
-import { ONE, ZERO } from '../constants/numericConstants';
-import { BN } from '../index';
+import {
+	BID_ASK_SPREAD_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_PRECISION,
+	ONE,
+	ZERO,
+} from '../constants/numericConstants';
+import { BN, PerpMarketAccount } from '../index';
+import { assert } from '../assert/assert';
+
+export function oraclePriceBands(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const maxPercentDiff =
+		market.marginRatioInitial - market.marginRatioMaintenance;
+	const offset = oraclePriceData.price
+		.mul(new BN(maxPercentDiff))
+		.div(MARGIN_PRECISION);
+
+	assert(offset.gt(ZERO));
+
+	return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
 
 export function isOracleValid(
 	amm: AMM,
@@ -9,22 +31,24 @@ export function isOracleValid(
 	oracleGuardRails: OracleGuardRails,
 	slot: number
 ): boolean {
-	const isOraclePriceNonPositive = oraclePriceData.price.lt(ZERO);
+	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
 	const isOraclePriceTooVolatile =
 		oraclePriceData.price
-			.div(BN.max(ONE, amm.lastOraclePriceTwap))
+			.div(BN.max(ONE, amm.historicalOracleData.lastOraclePriceTwap))
 			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
-		amm.lastOraclePriceTwap
+		amm.historicalOracleData.lastOraclePriceTwap
 			.div(BN.max(ONE, oraclePriceData.price))
 			.gt(oracleGuardRails.validity.tooVolatileRatio);
 
-	const isConfidenceTooLarge = oraclePriceData.price
-		.div(BN.max(ONE, oraclePriceData.confidence))
-		.lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+	const isConfidenceTooLarge = new BN(amm.baseSpread)
+		.add(BN.max(ONE, oraclePriceData.confidence))
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(oraclePriceData.price)
+		.gt(new BN(amm.maxSpread));
 
 	const oracleIsStale = oraclePriceData.slot
 		.sub(new BN(slot))
-		.gt(oracleGuardRails.validity.slotsBeforeStale);
+		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
 
 	return !(
 		!oraclePriceData.hasSufficientNumberOfDataPoints ||
@@ -34,3 +58,33 @@ export function isOracleValid(
 		isConfidenceTooLarge
 	);
 }
+
+export function isOracleTooDivergent(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	now: BN
+): boolean {
+	const sinceLastUpdate = now.sub(
+		amm.historicalOracleData.lastOraclePriceTwapTs
+	);
+	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
+	const oracleTwap5min = amm.historicalOracleData.lastOraclePriceTwap5Min
+		.mul(sinceStart)
+		.add(oraclePriceData.price)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+	const oracleSpreadPct = oracleSpread.mul(PRICE_PRECISION).div(oracleTwap5min);
+
+	const tooDivergent = oracleSpreadPct
+		.abs()
+		.gte(
+			BID_ASK_SPREAD_PRECISION.mul(
+				oracleGuardRails.priceDivergence.markOracleDivergenceNumerator
+			).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator)
+		);
+
+	return tooDivergent;
+}