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

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,

package/src/math/orders.js

@@ -0,0 +1,153 @@
+"use strict";
+exports.__esModule = true;
+exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+var types_1 = require("../types");
+var numericConstants_1 = require("../constants/numericConstants");
+var anchor_1 = require("@project-serum/anchor");
+var auction_1 = require("./auction");
+var market_1 = require("./market");
+var amm_1 = require("./amm");
+function isOrderRiskIncreasing(user, order) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    var position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if no position exists, it's risk increasing
+    if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return true;
+    }
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return true;
+    }
+    var baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    // if order will flip position
+    if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(numericConstants_1.TWO))) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
+function isOrderRiskIncreasingInSameDirection(user, order) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    var position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if no position exists, it's risk increasing
+    if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return true;
+    }
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
+function isOrderReduceOnly(user, order) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
+        return false;
+    }
+    var position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if position is long and order is long
+    if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'long')) {
+        return false;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
+        (0, types_1.isVariant)(order.direction, 'short')) {
+        return false;
+    }
+    return true;
+}
+exports.isOrderReduceOnly = isOrderReduceOnly;
+function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
+    var remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function getLimitPrice(order, market, oraclePriceData, slot) {
+    var limitPrice;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+        if (!(0, auction_1.isAuctionComplete)(order, slot)) {
+            limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else if ((0, types_1.isVariant)(order.direction, 'long')) {
+            var askPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+            var delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = askPrice.add(delta);
+        }
+        else {
+            var bidPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+            var delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = bidPrice.sub(delta);
+        }
+    }
+    else {
+        limitPrice = order.price;
+    }
+    return limitPrice;
+}
+exports.getLimitPrice = getLimitPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot, maxAuctionDuration) {
+    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
+        isOrderExpired(order, slot, maxAuctionDuration));
+}
+exports.isFillableByVAMM = isFillableByVAMM;
+function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+        order.triggered === false) {
+        return numericConstants_1.ZERO;
+    }
+    var limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+    var baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData);
+    var maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(market.amm, order.direction);
+    return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData) {
+    var _a = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData), maxAmountToTrade = _a[0], direction = _a[1];
+    var baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
+    // Check that directions are the same
+    var sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    return baseAssetAmount.gt(order.baseAssetAmount)
+        ? order.baseAssetAmount
+        : baseAssetAmount;
+}
+exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
+function isSameDirection(firstDirection, secondDirection) {
+    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
+        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
+}
+function isOrderExpired(order, slot, maxAuctionDuration) {
+    if (!(0, types_1.isVariant)(order.orderType, 'market') ||
+        !(0, types_1.isVariant)(order.status, 'open')) {
+        return false;
+    }
+    return new anchor_1.BN(slot).sub(order.slot).gt(new anchor_1.BN(maxAuctionDuration));
+}
+exports.isOrderExpired = isOrderExpired;

package/src/math/orders.ts

@@ -2,7 +2,7 @@ import { ClearingHouseUser } from '../clearingHouseUser';
 import {
 	isOneOfVariant,
 	isVariant,
-	MarketAccount,
+	PerpMarketAccount,
 	Order,
 	PositionDirection,
 } from '../types';
@@ -131,7 +131,7 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
@@ -161,7 +161,7 @@ export function getLimitPrice(
 
 export function isFillableByVAMM(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number,
 	maxAuctionDuration: number
@@ -180,7 +180,7 @@ export function isFillableByVAMM(
 
 export function calculateBaseAssetAmountForAmmToFulfill(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
@@ -209,7 +209,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 
 export function calculateBaseAssetAmountToFillUpToLimitPrice(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	limitPrice: BN,
 	oraclePriceData: OraclePriceData
 ): BN {