@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.10

package/src/math/auction.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuctionPrice = exports.isAuctionComplete = void 0;
+const types_1 = require("../types");
+const _1 = require("../.");
+function isAuctionComplete(order, slot) {
+    if (order.auctionDuration === 0) {
+        return true;
+    }
+    return new _1.BN(slot).sub(order.slot).gt(new _1.BN(order.auctionDuration));
+}
+exports.isAuctionComplete = isAuctionComplete;
+function getAuctionPrice(order, slot) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    const deltaDenominator = new _1.BN(order.auctionDuration);
+    const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
+    if (deltaDenominator.eq(_1.ZERO)) {
+        return order.auctionEndPrice;
+    }
+    let priceDelta;
+    if (types_1.isVariant(order.direction, 'long')) {
+        priceDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let price;
+    if (types_1.isVariant(order.direction, 'long')) {
+        price = order.auctionStartPrice.add(priceDelta);
+    }
+    else {
+        price = order.auctionStartPrice.sub(priceDelta);
+    }
+    return price;
+}
+exports.getAuctionPrice = getAuctionPrice;

package/src/math/auction.ts

@@ -2,7 +2,11 @@ import { isVariant, Order } from '../types';
 import { BN, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
-	return new BN(slot).sub(order.slot).gte(new BN(order.auctionDuration));
+	if (order.auctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
 }
 
 export function getAuctionPrice(order: Order, slot: number): BN {

package/src/math/bankBalance.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+function getBalance(tokenAmount, bank, balanceType) {
+    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
+        ? bank.cumulativeDepositInterest
+        : bank.cumulativeBorrowInterest;
+    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+    if (!balance.eq(numericConstants_1.ZERO) && types_1.isVariant(balanceType, 'borrow')) {
+        balance = balance.add(numericConstants_1.ONE);
+    }
+    return balance;
+}
+exports.getBalance = getBalance;
+function getTokenAmount(balanceAmount, bank, balanceType) {
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
+        ? bank.cumulativeDepositInterest
+        : bank.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function calculateInterestAccumulated(bank, now) {
+    const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
+    const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
+    let utilization;
+    if (token_borrow_amount.eq(numericConstants_1.ZERO) && token_deposit_amount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.ZERO;
+    }
+    else if (token_deposit_amount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.BANK_UTILIZATION_PRECISION;
+    }
+    else {
+        utilization = token_borrow_amount
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(token_deposit_amount);
+    }
+    let interest_rate;
+    if (utilization.gt(bank.optimalUtilization)) {
+        const surplusUtilization = utilization.sub(bank.optimalUtilization);
+        const borrowRateSlope = bank.maxBorrowRate
+            .sub(bank.optimalBorrowRate)
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interest_rate = bank.optimalBorrowRate.add(surplusUtilization.mul(borrowRateSlope).div(numericConstants_1.BANK_UTILIZATION_PRECISION));
+    }
+    else {
+        const borrowRateSlope = bank.optimalBorrowRate
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interest_rate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
+    }
+    const timeSinceLastUpdate = now.sub(bank.lastUpdated);
+    const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
+    const modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
+    const borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.BANK_INTEREST_PRECISION)
+        .add(numericConstants_1.ONE);
+    const depositInterest = bank.cumulativeDepositInterest
+        .mul(modifiedDepositRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.BANK_INTEREST_PRECISION);
+    return { borrowInterest, depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;

package/src/math/conversion.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToNumber = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PRECISION) => {
+    if (!bigNumber)
+        return 0;
+    return (bigNumber.div(precision).toNumber() +
+        bigNumber.mod(precision).toNumber() / precision.toNumber());
+};
+exports.convertToNumber = convertToNumber;

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/market.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+const types_1 = require("../types");
+const amm_1 = require("./amm");
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateMarkPrice(market, oraclePriceData) {
+    const newAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
+    return 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) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
+    return 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) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
+    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateAskPrice = calculateAskPrice;
+function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', baseAssetAmount.abs(), amm_1.getSwapDirection('base', direction));
+    const newAmm = Object.assign({}, market.amm);
+    const newMarket = Object.assign({}, market);
+    newMarket.amm = newAmm;
+    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+    return newMarket;
+}
+exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
+function calculateMarkOracleSpread(market, oraclePriceData) {
+    const markPrice = calculateMarkPrice(market, oraclePriceData);
+    return calculateOracleSpread(markPrice, oraclePriceData);
+}
+exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
+function calculateOracleSpread(price, oraclePriceData) {
+    return price.sub(oraclePriceData.price);
+}
+exports.calculateOracleSpread = calculateOracleSpread;

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/orders.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@project-serum/anchor");
+const auction_1 = require("./auction");
+const market_1 = require("./market");
+function isOrderRiskIncreasing(user, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const 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) && types_1.isVariant(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return true;
+    }
+    const 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 (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const 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) && types_1.isVariant(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
+function isOrderReduceOnly(user, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if position is long and order is long
+    if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'long')) {
+        return false;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return false;
+    }
+    return true;
+}
+exports.isOrderReduceOnly = isOrderReduceOnly;
+function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
+    const remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function getLimitPrice(order, market, oraclePriceData, slot) {
+    let limitPrice;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    else if (types_1.isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+        if (auction_1.isAuctionComplete(order, slot)) {
+            limitPrice = auction_1.getAuctionPrice(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else if (types_1.isVariant(order.direction, 'long')) {
+            const askPrice = market_1.calculateAskPrice(market, oraclePriceData);
+            const delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = askPrice.add(delta);
+        }
+        else {
+            const bidPrice = market_1.calculateBidPrice(market, oraclePriceData);
+            const delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = bidPrice.sub(delta);
+        }
+    }
+    else {
+        limitPrice = order.price;
+    }
+    return limitPrice;
+}
+exports.getLimitPrice = getLimitPrice;

package/src/math/orders.ts

@@ -1,9 +1,10 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
+import { isOneOfVariant, isVariant, MarketAccount, Order } 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';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -120,24 +121,27 @@ 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;
 	}