@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/math/margin.js

@@ -0,0 +1,77 @@
+"use strict";
+exports.__esModule = true;
+exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+var utils_1 = require("./utils");
+var numericConstants_1 = require("../constants/numericConstants");
+var anchor_1 = require("@project-serum/anchor");
+var assert_1 = require("../assert/assert");
+function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, liabilityWeight, precision) {
+    if (imfFactor.eq(numericConstants_1.ZERO)) {
+        return liabilityWeight;
+    }
+    var sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
+    var denom0 = anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor));
+    (0, assert_1.assert)(denom0.gt(numericConstants_1.ZERO));
+    var liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor))));
+    var denom = new anchor_1.BN(100000).mul(numericConstants_1.SPOT_MARKET_IMF_PRECISION).div(precision);
+    (0, assert_1.assert)(denom.gt(numericConstants_1.ZERO));
+    var sizePremiumLiabilityWeight = liabilityWeightNumerator.add(sizeSqrt // 1e5
+        .mul(imfFactor)
+        .div(denom) // 1e5
+    );
+    var maxLiabilityWeight = anchor_1.BN.max(liabilityWeight, sizePremiumLiabilityWeight);
+    return maxLiabilityWeight;
+}
+exports.calculateSizePremiumLiabilityWeight = calculateSizePremiumLiabilityWeight;
+function calculateSizeDiscountAssetWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, assetWeight) {
+    if (imfFactor.eq(numericConstants_1.ZERO)) {
+        return assetWeight;
+    }
+    var sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
+    var imfNumerator = numericConstants_1.SPOT_MARKET_IMF_PRECISION.add(numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(new anchor_1.BN(10)));
+    var sizeDiscountAssetWeight = imfNumerator
+        .mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION)
+        .div(numericConstants_1.SPOT_MARKET_IMF_PRECISION.add(sizeSqrt // 1e5
+        .mul(imfFactor)
+        .div(new anchor_1.BN(100000)) // 1e5
+    ));
+    var minAssetWeight = anchor_1.BN.min(assetWeight, sizeDiscountAssetWeight);
+    return minAssetWeight;
+}
+exports.calculateSizeDiscountAssetWeight = calculateSizeDiscountAssetWeight;
+function calculateOraclePriceForPerpMargin(perpPosition, market, oraclePriceData) {
+    var oraclePriceOffset = anchor_1.BN.min(new anchor_1.BN(market.amm.maxSpread)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BID_ASK_SPREAD_PRECISION), oraclePriceData.confidence.add(new anchor_1.BN(market.amm.baseSpread)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BID_ASK_SPREAD_PRECISION)));
+    var marginPrice;
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+    }
+    else {
+        marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+    }
+    return marginPrice;
+}
+exports.calculateOraclePriceForPerpMargin = calculateOraclePriceForPerpMargin;
+function calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData) {
+    return perpPosition.baseAssetAmount
+        .abs()
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+}
+exports.calculateBaseAssetValueWithOracle = calculateBaseAssetValueWithOracle;
+function calculateWorstCaseBaseAssetAmount(perpPosition) {
+    var allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+    var allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
+    if (allBids.abs().gt(allAsks.abs())) {
+        return allBids;
+    }
+    else {
+        return allAsks;
+    }
+}
+exports.calculateWorstCaseBaseAssetAmount = calculateWorstCaseBaseAssetAmount;

package/src/math/margin.ts

@@ -1,7 +1,7 @@
 import { squareRootBN } from './utils';
 import {
-	BANK_WEIGHT_PRECISION,
-	BANK_IMF_PRECISION,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	SPOT_MARKET_IMF_PRECISION,
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -9,7 +9,8 @@ import {
 } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, UserPosition } from '..';
+import { PerpMarketAccount, PerpPosition } from '..';
+import { assert } from '../assert/assert';
 
 export function calculateSizePremiumLiabilityWeight(
 	size: BN, // AMM_RESERVE_PRECISION
@@ -22,14 +23,22 @@ export function calculateSizePremiumLiabilityWeight(
 	}
 
 	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 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), BANK_IMF_PRECISION.div(imfFactor)))
+		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(new BN(100_000).mul(BANK_IMF_PRECISION).div(precision)) // 1e5
+			.div(denom) // 1e5
 	);
 
 	const maxLiabilityWeight = BN.max(
@@ -49,17 +58,19 @@ export function calculateSizeDiscountAssetWeight(
 	}
 
 	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
-	const imfNumerator = BANK_IMF_PRECISION.add(
-		BANK_IMF_PRECISION.div(new BN(10))
+	const imfNumerator = SPOT_MARKET_IMF_PRECISION.add(
+		SPOT_MARKET_IMF_PRECISION.div(new BN(10))
 	);
 
-	const sizeDiscountAssetWeight = imfNumerator.mul(BANK_WEIGHT_PRECISION).div(
-		BANK_IMF_PRECISION.add(
-			sizeSqrt // 1e5
-				.mul(imfFactor)
-				.div(new BN(100_000)) // 1e5
-		)
-	);
+	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);
 
@@ -67,8 +78,8 @@ export function calculateSizeDiscountAssetWeight(
 }
 
 export function calculateOraclePriceForPerpMargin(
-	marketPosition: UserPosition,
-	market: MarketAccount,
+	perpPosition: PerpPosition,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const oraclePriceOffset = BN.min(
@@ -83,7 +94,7 @@ export function calculateOraclePriceForPerpMargin(
 	);
 
 	let marginPrice: BN;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
 		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
 	} else {
 		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
@@ -93,21 +104,21 @@ export function calculateOraclePriceForPerpMargin(
 }
 
 export function calculateBaseAssetValueWithOracle(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
-	return marketPosition.baseAssetAmount
+	return perpPosition.baseAssetAmount
 		.abs()
 		.mul(oraclePriceData.price)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
 }
 
 export function calculateWorstCaseBaseAssetAmount(
-	marketPosition: UserPosition
+	perpPosition: PerpPosition
 ): BN {
-	const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
-	const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);
+	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
 
 	if (allBids.abs().gt(allAsks.abs())) {
 		return allBids;

package/src/math/market.js

@@ -0,0 +1,105 @@
+"use strict";
+exports.__esModule = true;
+exports.calculateNetUserImbalance = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+var anchor_1 = require("@project-serum/anchor");
+var types_1 = require("../types");
+var amm_1 = require("./amm");
+var margin_1 = require("./margin");
+var numericConstants_1 = require("../constants/numericConstants");
+var spotBalance_1 = require("./spotBalance");
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateMarkPrice(market, oraclePriceData) {
+    var newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    return (0, amm_1.calculatePrice)(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
+}
+exports.calculateMarkPrice = calculateMarkPrice;
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateBidPrice(market, oraclePriceData) {
+    var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, newPeg = _a.newPeg;
+    return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateBidPrice = calculateBidPrice;
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateAskPrice(market, oraclePriceData) {
+    var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, newPeg = _a.newPeg;
+    return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateAskPrice = calculateAskPrice;
+function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
+    var _a = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', direction)), newQuoteAssetReserve = _a[0], newBaseAssetReserve = _a[1];
+    var newAmm = Object.assign({}, market.amm);
+    var newMarket = Object.assign({}, market);
+    newMarket.amm = newAmm;
+    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+    return newMarket;
+}
+exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
+function calculateMarkOracleSpread(market, oraclePriceData) {
+    var markPrice = calculateMarkPrice(market, oraclePriceData);
+    return calculateOracleSpread(markPrice, oraclePriceData);
+}
+exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
+function calculateOracleSpread(price, oraclePriceData) {
+    return price.sub(oraclePriceData.price);
+}
+exports.calculateOracleSpread = calculateOracleSpread;
+function calculateMarketMarginRatio(market, size, marginCategory) {
+    var marginRatio;
+    switch (marginCategory) {
+        case 'Initial':
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, market.imfFactor, new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            break;
+        case 'Maintenance':
+            marginRatio = market.marginRatioMaintenance;
+            break;
+    }
+    return marginRatio;
+}
+exports.calculateMarketMarginRatio = calculateMarketMarginRatio;
+function calculateUnrealizedAssetWeight(market, unrealizedPnl, marginCategory) {
+    var assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, market.unrealizedImfFactor, new anchor_1.BN(market.unrealizedInitialAssetWeight));
+            break;
+        case 'Maintenance':
+            assetWeight = new anchor_1.BN(market.unrealizedMaintenanceAssetWeight);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateUnrealizedAssetWeight = calculateUnrealizedAssetWeight;
+function calculateMarketAvailablePNL(perpMarket, spotMarket) {
+    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.balance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+}
+exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
+function calculateNetUserImbalance(market, bank, oraclePriceData) {
+    var netUserPositionValue = market.amm.netBaseAssetAmount
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BASE_PRECISION)
+        .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    var netUserCostBasis = market.amm.quoteAssetAmountLong
+        .add(market.amm.quoteAssetAmountShort)
+        .sub(market.amm.cumulativeSocialLoss);
+    var userEntitledPnl = netUserPositionValue.add(netUserCostBasis);
+    var pnlPool = (0, spotBalance_1.getTokenAmount)(market.pnlPool.balance, bank, types_1.SpotBalanceType.DEPOSIT);
+    var imbalance = userEntitledPnl.sub(pnlPool);
+    return imbalance;
+}
+exports.calculateNetUserImbalance = calculateNetUserImbalance;

package/src/math/market.ts

@@ -1,10 +1,10 @@
 import { BN } from '@project-serum/anchor';
 import {
-	MarketAccount,
+	PerpMarketAccount,
 	PositionDirection,
 	MarginCategory,
-	BankAccount,
-	BankBalanceType,
+	SpotMarketAccount,
+	SpotBalanceType,
 } from '../types';
 import {
 	calculateAmmReservesAfterSwap,
@@ -18,8 +18,13 @@ import {
 	calculateSizePremiumLiabilityWeight,
 } from './margin';
 import { OraclePriceData } from '../oracles/types';
-import { MARGIN_PRECISION } from '../constants/numericConstants';
-import { getTokenAmount } from './bankBalance';
+import {
+	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_TO_QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { getTokenAmount } from './spotBalance';
 
 /**
  * Calculates market mark price
@@ -28,7 +33,7 @@ import { getTokenAmount } from './bankBalance';
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
 export function calculateMarkPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
@@ -46,7 +51,7 @@ export function calculateMarkPrice(
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
 export function calculateBidPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -66,7 +71,7 @@ export function calculateBidPrice(
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
 export function calculateAskPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -82,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,
@@ -102,7 +107,7 @@ export function calculateNewMarketAfterTrade(
 }
 
 export function calculateMarkOracleSpread(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const markPrice = calculateMarkPrice(market, oraclePriceData);
@@ -117,7 +122,7 @@ export function calculateOracleSpread(
 }
 
 export function calculateMarketMarginRatio(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	size: BN,
 	marginCategory: MarginCategory
 ): number {
@@ -140,18 +145,34 @@ export function calculateMarketMarginRatio(
 }
 
 export function calculateUnrealizedAssetWeight(
-	market: MarketAccount,
+	market: PerpMarketAccount,
+	quoteSpotMarket: SpotMarketAccount,
 	unrealizedPnl: BN,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory,
+	oraclePriceData: OraclePriceData
 ): BN {
 	let assetWeight: BN;
-
 	switch (marginCategory) {
 		case 'Initial':
+			assetWeight = new BN(market.unrealizedInitialAssetWeight);
+
+			if (market.unrealizedMaxImbalance.gt(ZERO)) {
+				const netUnsettledPnl = calculateNetUserImbalance(
+					market,
+					quoteSpotMarket,
+					oraclePriceData
+				);
+				if (netUnsettledPnl.gt(market.unrealizedMaxImbalance)) {
+					assetWeight = assetWeight
+						.mul(market.unrealizedMaxImbalance)
+						.div(netUnsettledPnl);
+				}
+			}
+
 			assetWeight = calculateSizeDiscountAssetWeight(
 				unrealizedPnl,
 				market.unrealizedImfFactor,
-				new BN(market.unrealizedInitialAssetWeight)
+				assetWeight
 			);
 			break;
 		case 'Maintenance':
@@ -163,8 +184,39 @@ export function calculateUnrealizedAssetWeight(
 }
 
 export function calculateMarketAvailablePNL(
-	market: MarketAccount,
-	bank: BankAccount
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount
+): BN {
+	return getTokenAmount(
+		perpMarket.pnlPool.balance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+}
+
+export function calculateNetUserImbalance(
+	market: PerpMarketAccount,
+	bank: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
 ): BN {
-	return getTokenAmount(market.pnlPool.balance, bank, BankBalanceType.DEPOSIT);
+	const netUserPositionValue = market.amm.netBaseAssetAmount
+		.mul(oraclePriceData.price)
+		.div(BASE_PRECISION)
+		.div(PRICE_TO_QUOTE_PRECISION);
+
+	const netUserCostBasis = market.amm.quoteAssetAmountLong
+		.add(market.amm.quoteAssetAmountShort)
+		.sub(market.amm.cumulativeSocialLoss);
+
+	const userEntitledPnl = netUserPositionValue.add(netUserCostBasis);
+
+	const pnlPool = getTokenAmount(
+		market.pnlPool.balance,
+		bank,
+		SpotBalanceType.DEPOSIT
+	);
+
+	const imbalance = userEntitledPnl.sub(pnlPool);
+
+	return imbalance;
 }

package/src/math/oracles.js

@@ -1,20 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleValid = void 0;
-const numericConstants_1 = require("../constants/numericConstants");
-const index_1 = require("../index");
+exports.__esModule = true;
+exports.isOracleTooDivergent = exports.isOracleValid = exports.oraclePriceBands = void 0;
+var numericConstants_1 = require("../constants/numericConstants");
+var index_1 = require("../index");
+var assert_1 = require("../assert/assert");
+function oraclePriceBands(market, oraclePriceData) {
+    var maxPercentDiff = market.marginRatioInitial - market.marginRatioMaintenance;
+    var offset = oraclePriceData.price
+        .mul(new index_1.BN(maxPercentDiff))
+        .div(numericConstants_1.MARGIN_PRECISION);
+    (0, assert_1.assert)(offset.gt(numericConstants_1.ZERO));
+    return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
+exports.oraclePriceBands = oraclePriceBands;
 function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
-    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
-    const isOraclePriceTooVolatile = oraclePriceData.price
+    var isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
+    var isOraclePriceTooVolatile = oraclePriceData.price
         .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
         amm.lastOraclePriceTwap
             .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
             .gt(oracleGuardRails.validity.tooVolatileRatio);
-    const isConfidenceTooLarge = oraclePriceData.price
-        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
-        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
-    const oracleIsStale = oraclePriceData.slot
+    var isConfidenceTooLarge = new index_1.BN(amm.baseSpread)
+        .add(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(oraclePriceData.price)
+        .gt(new index_1.BN(amm.maxSpread));
+    var oracleIsStale = oraclePriceData.slot
         .sub(new index_1.BN(slot))
         .gt(oracleGuardRails.validity.slotsBeforeStale);
     return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
@@ -24,3 +36,21 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         isConfidenceTooLarge);
 }
 exports.isOracleValid = isOracleValid;
+function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
+    var sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+    var sinceStart = index_1.BN.max(numericConstants_1.ZERO, new index_1.BN(60 * 5).sub(sinceLastUpdate));
+    var oracleTwap5min = amm.lastOraclePriceTwap5min
+        .mul(sinceStart)
+        .add(oraclePriceData.price)
+        .mul(sinceLastUpdate)
+        .div(sinceStart.add(sinceLastUpdate));
+    var oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+    var oracleSpreadPct = oracleSpread
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(oracleTwap5min);
+    var tooDivergent = oracleSpreadPct
+        .abs()
+        .gte(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(oracleGuardRails.priceDivergence.markOracleDivergenceNumerator).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator));
+    return tooDivergent;
+}
+exports.isOracleTooDivergent = isOracleTooDivergent;

package/src/math/oracles.ts

@@ -2,11 +2,28 @@ import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import {
 	BID_ASK_SPREAD_PRECISION,
+	MARGIN_PRECISION,
 	MARK_PRICE_PRECISION,
 	ONE,
 	ZERO,
 } from '../constants/numericConstants';
-import { BN } from '../index';
+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,