@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.20

package/src/math/funding.js

@@ -0,0 +1,248 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFundingPool = exports.calculateLongShortFundingRateAndLiveTwaps = exports.calculateLongShortFundingRate = exports.calculateEstimatedFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const market_1 = require("./market");
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // periodAdjustment
+        // 	1: hourly
+        //  24: daily
+        //  24 * 365.25: annualized
+        const secondsInHour = new anchor_1.BN(3600);
+        const hoursInDay = new anchor_1.BN(24);
+        const ONE = new anchor_1.BN(1);
+        if (!market.initialized) {
+            return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const payFreq = new anchor_1.BN(market.amm.fundingPeriod);
+        // todo: sufficiently differs from blockchain timestamp?
+        const now = new anchor_1.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 = anchor_1.BN.max(secondsInHour, anchor_1.BN.max(numericConstants_1.ZERO, secondsInHour.sub(timeSinceLastMarkChange)));
+        const baseAssetPriceWithMantissa = market_1.calculateMarkPrice(market, oraclePriceData);
+        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.lastOraclePriceTwap;
+        const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+        const oracleInvalidDuration = anchor_1.BN.max(numericConstants_1.ZERO, lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs));
+        const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
+        const oracleTwapTimeSinceLastUpdate = anchor_1.BN.max(ONE, anchor_1.BN.min(secondsInHour, anchor_1.BN.max(ONE, secondsInHour.sub(timeSinceLastOracleTwapUpdate))));
+        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(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(lastOracleTwapWithMantissa);
+            // verify pyth live input is within 10% of last twap for live update
+            if (oracleLiveVsTwap.lte(numericConstants_1.MARK_PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
+                oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
+                    .mul(lastOracleTwapWithMantissa)
+                    .add(timeSinceLastMarkChange.mul(oraclePrice))
+                    .div(timeSinceLastMarkChange.add(oracleTwapTimeSinceLastUpdate));
+            }
+        }
+        const shrunkLastOracleTwapwithMantissa = oracleTwapTimeSinceLastUpdate
+            .mul(lastOracleTwapWithMantissa)
+            .add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
+            .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
+        const twapSpread = lastMarkTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
+        const twapSpreadPct = twapSpread
+            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(new anchor_1.BN(100))
+            .div(shrunkLastOracleTwapwithMantissa);
+        const lowerboundEst = twapSpreadPct
+            .mul(payFreq)
+            .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
+            .mul(periodAdjustment)
+            .div(secondsInHour)
+            .div(secondsInHour)
+            .div(hoursInDay);
+        const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+        const interpRateQuote = twapSpreadPct
+            .mul(periodAdjustment)
+            .div(hoursInDay)
+            .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
+        let feePoolSize = calculateFundingPool(market);
+        if (interpRateQuote.lt(new anchor_1.BN(0))) {
+            feePoolSize = feePoolSize.mul(new anchor_1.BN(-1));
+        }
+        let cappedAltEst;
+        let largerSide;
+        let smallerSide;
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+            largerSide = market.baseAssetAmountLong.abs();
+            smallerSide = market.baseAssetAmountShort.abs();
+            if (twapSpread.gt(new anchor_1.BN(0))) {
+                return [
+                    markTwapWithMantissa,
+                    oracleTwapWithMantissa,
+                    lowerboundEst,
+                    interpEst,
+                    interpEst,
+                ];
+            }
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+            largerSide = market.baseAssetAmountShort.abs();
+            smallerSide = market.baseAssetAmountLong.abs();
+            if (twapSpread.lt(new anchor_1.BN(0))) {
+                return [
+                    markTwapWithMantissa,
+                    oracleTwapWithMantissa,
+                    lowerboundEst,
+                    interpEst,
+                    interpEst,
+                ];
+            }
+        }
+        else {
+            return [
+                markTwapWithMantissa,
+                oracleTwapWithMantissa,
+                lowerboundEst,
+                interpEst,
+                interpEst,
+            ];
+        }
+        if (largerSide.gt(numericConstants_1.ZERO)) {
+            // funding smaller flow
+            cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
+            const feePoolTopOff = feePoolSize
+                .mul(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION);
+            cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
+            cappedAltEst = cappedAltEst
+                .mul(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(oracleTwapWithMantissa)
+                .mul(periodAdjustment);
+            if (cappedAltEst.abs().gte(interpEst.abs())) {
+                cappedAltEst = interpEst;
+            }
+        }
+        else {
+            cappedAltEst = interpEst;
+        }
+        return [
+            markTwapWithMantissa,
+            oracleTwapWithMantissa,
+            lowerboundEst,
+            cappedAltEst,
+            interpEst,
+        ];
+    });
+}
+exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1), estimationMethod) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_1, _2, lowerboundEst, cappedAltEst, interpEst] = yield 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;
+        }
+    });
+}
+exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_1, _2, _, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+            return [cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+            return [interpEst, cappedAltEst];
+        }
+        else {
+            return [interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+            return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+            return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
+        }
+        else {
+            return [markTwapLive, oracleTwapLive, interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRateAndLiveTwaps = calculateLongShortFundingRateAndLiveTwaps;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+function calculateFundingPool(market) {
+    // todo
+    const totalFeeLB = market.amm.totalExchangeFee.div(new anchor_1.BN(2));
+    const feePool = anchor_1.BN.max(numericConstants_1.ZERO, market.amm.totalFeeMinusDistributions
+        .sub(totalFeeLB)
+        .mul(new anchor_1.BN(1))
+        .div(new anchor_1.BN(3)));
+    return feePool;
+}
+exports.calculateFundingPool = calculateFundingPool;

package/src/math/margin.ts

@@ -0,0 +1,124 @@
+import { squareRootBN } from './utils';
+import {
+	BANK_WEIGHT_PRECISION,
+	BANK_IMF_PRECISION,
+	ZERO,
+	BID_ASK_SPREAD_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	MARK_PRICE_PRECISION,
+} from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, UserPosition } from '..';
+
+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.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const liabilityWeightNumerator = liabilityWeight.sub(
+		liabilityWeight.div(BN.max(new BN(1), BANK_IMF_PRECISION.div(imfFactor)))
+	);
+
+	const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(
+		sizeSqrt // 1e5
+			.mul(imfFactor)
+			.div(new BN(100_000).mul(BANK_IMF_PRECISION).div(precision)) // 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.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 sizeDiscountAssetWeight = imfNumerator.mul(BANK_WEIGHT_PRECISION).div(
+		BANK_IMF_PRECISION.add(
+			sizeSqrt // 1e5
+				.mul(imfFactor)
+				.div(new BN(100_000)) // 1e5
+		)
+	);
+
+	const minAssetWeight = BN.min(assetWeight, sizeDiscountAssetWeight);
+
+	return minAssetWeight;
+}
+
+export function calculateOraclePriceForPerpMargin(
+	marketPosition: UserPosition,
+	market: MarketAccount,
+	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 (marketPosition.baseAssetAmount.gt(ZERO)) {
+		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+	} else {
+		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+	}
+
+	return marginPrice;
+}
+
+export function calculateMarginBaseAssetValue(
+	market: MarketAccount,
+	marketPosition: UserPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	const marginPrice = calculateOraclePriceForPerpMargin(
+		marketPosition,
+		market,
+		oraclePriceData
+	);
+	const baseAssetValue = marketPosition.baseAssetAmount
+		.abs()
+		.mul(marginPrice)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+	return baseAssetValue;
+}
+
+export function calculateWorstCaseBaseAssetAmount(
+	marketPosition: UserPosition
+): BN {
+	const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
+	const allAsks = marketPosition.baseAssetAmount.add(marketPosition.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 {
+	MarketAccount,
+	PositionDirection,
+	MarginCategory,
+	BankAccount,
+	BankBalanceType,
+} from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -7,7 +13,13 @@ import {
 	getSwapDirection,
 	calculateUpdatedAMM,
 } from './amm';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 import { OraclePriceData } from '../oracles/types';
+import { MARGIN_PRECISION } from '../constants/numericConstants';
+import { getTokenAmount } from './bankBalance';
 
 /**
  * Calculates market mark price
@@ -103,3 +115,56 @@ export function calculateOracleSpread(
 ): BN {
 	return price.sub(oraclePriceData.price);
 }
+
+export function calculateMarketMarginRatio(
+	market: MarketAccount,
+	size: BN,
+	marginCategory: MarginCategory
+): number {
+	let marginRatio;
+	switch (marginCategory) {
+		case 'Initial':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				market.imfFactor,
+				new BN(market.marginRatioInitial),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+		case 'Maintenance':
+			marginRatio = market.marginRatioMaintenance;
+			break;
+	}
+
+	return marginRatio;
+}
+
+export function calculateUnrealizedAssetWeight(
+	market: MarketAccount,
+	unrealizedPnl: BN,
+	marginCategory: MarginCategory
+): BN {
+	let assetWeight: BN;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				unrealizedPnl,
+				market.unrealizedImfFactor,
+				new BN(market.unrealizedInitialAssetWeight)
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = new BN(market.unrealizedMaintenanceAssetWeight);
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateMarketAvailablePNL(
+	market: MarketAccount,
+	bank: BankAccount
+): BN {
+	return getTokenAmount(market.pnlPool.balance, bank, BankBalanceType.DEPOSIT);
+}

package/src/math/oracles.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOracleValid = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
+    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const 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
+        .sub(new index_1.BN(slot))
+        .gt(oracleGuardRails.validity.slotsBeforeStale);
+    return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
+        oracleIsStale ||
+        isOraclePriceNonPositive ||
+        isOraclePriceTooVolatile ||
+        isConfidenceTooLarge);
+}
+exports.isOracleValid = isOracleValid;

package/src/math/oracles.ts

@@ -1,6 +1,11 @@
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
-import { ONE, ZERO } from '../constants/numericConstants';
+import {
+	BID_ASK_SPREAD_PRECISION,
+	MARK_PRICE_PRECISION,
+	ONE,
+	ZERO,
+} from '../constants/numericConstants';
 import { BN } from '../index';
 
 export function isOracleValid(
@@ -9,7 +14,7 @@ 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))
@@ -18,9 +23,11 @@ export function isOracleValid(
 			.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))
@@ -34,3 +41,33 @@ export function isOracleValid(
 		isConfidenceTooLarge
 	);
 }
+
+export function isOracleTooDivergent(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	now: BN
+): boolean {
+	const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
+	const oracleTwap5min = amm.lastOraclePriceTwap5min
+		.mul(sinceStart)
+		.add(oraclePriceData.price)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+	const oracleSpreadPct = oracleSpread
+		.mul(MARK_PRICE_PRECISION)
+		.div(oracleTwap5min);
+
+	const tooDivergent = oracleSpreadPct
+		.abs()
+		.gte(
+			BID_ASK_SPREAD_PRECISION.mul(
+				oracleGuardRails.priceDivergence.markOracleDivergenceNumerator
+			).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator)
+		);
+
+	return tooDivergent;
+}

package/src/math/orders.ts

@@ -1,9 +1,20 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
+import {
+	isOneOfVariant,
+	isVariant,
+	MarketAccount,
+	Order,
+	PositionDirection,
+} from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { getAuctionPrice } from './auction';
+import { getAuctionPrice, isAuctionComplete } from './auction';
+import { calculateAskPrice, calculateBidPrice } from './market';
+import {
+	calculateMaxBaseAssetAmountFillable,
+	calculateMaxBaseAssetAmountToTrade,
+} from './amm';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -120,27 +131,115 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
+	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
 	let limitPrice;
 	if (!order.oraclePriceOffset.eq(ZERO)) {
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+		if (isAuctionComplete(order, slot)) {
+			limitPrice = getAuctionPrice(order, slot);
+		} else if (!order.price.eq(ZERO)) {
+			limitPrice = order.price;
+		} else if (isVariant(order.direction, 'long')) {
+			const askPrice = calculateAskPrice(market, oraclePriceData);
+			const delta = askPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = askPrice.add(delta);
 		} else {
-			limitPrice = floatingPrice;
+			const bidPrice = calculateBidPrice(market, oraclePriceData);
+			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
+			limitPrice = bidPrice.sub(delta);
 		}
-	} else if (
-		isVariant(order.orderType, 'market') ||
-		isVariant(order.orderType, 'triggerMarket')
-	) {
-		limitPrice = getAuctionPrice(order, slot);
 	} else {
 		limitPrice = order.price;
 	}
 
 	return limitPrice;
 }
+
+export function isFillableByVAMM(
+	order: Order,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): boolean {
+	return (
+		isAuctionComplete(order, slot) &&
+		!calculateBaseAssetAmountForAmmToFulfill(
+			order,
+			market,
+			oraclePriceData,
+			slot
+		).eq(ZERO)
+	);
+}
+
+export function calculateBaseAssetAmountForAmmToFulfill(
+	order: Order,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN {
+	if (
+		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+		order.triggered === false
+	) {
+		return ZERO;
+	}
+
+	const limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+	const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
+		order,
+		market,
+		limitPrice,
+		oraclePriceData
+	);
+
+	const maxBaseAssetAmount = calculateMaxBaseAssetAmountFillable(
+		market.amm,
+		order.direction
+	);
+
+	return BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+
+export function calculateBaseAssetAmountToFillUpToLimitPrice(
+	order: Order,
+	market: MarketAccount,
+	limitPrice: BN,
+	oraclePriceData: OraclePriceData
+): BN {
+	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
+		market.amm,
+		limitPrice,
+		order.direction,
+		oraclePriceData
+	);
+
+	const baseAssetAmount = standardizeBaseAssetAmount(
+		maxAmountToTrade,
+		market.amm.baseAssetAmountStepSize
+	);
+
+	// Check that directions are the same
+	const sameDirection = isSameDirection(direction, order.direction);
+	if (!sameDirection) {
+		return ZERO;
+	}
+
+	return baseAssetAmount.gt(order.baseAssetAmount)
+		? order.baseAssetAmount
+		: baseAssetAmount;
+}
+
+function isSameDirection(
+	firstDirection: PositionDirection,
+	secondDirection: PositionDirection
+): boolean {
+	return (
+		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
+		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
+	);
+}