@velocity-exchange/sdk 0.0.1

package/lib/node/math/oracles.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMultipleBetweenOracleSources = exports.trimVaaSignatures = exports.getNewOracleConfPct = exports.calculateLiveOracleStd = exports.calculateLiveOracleTwap = exports.isOracleTooDivergent = exports.isOracleValid = exports.getOracleValidity = exports.getMaxConfidenceIntervalMultiplier = exports.oraclePriceBands = void 0;
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+const assert_1 = require("../assert/assert");
+const anchor_1 = require("../isomorphic/anchor");
+function oraclePriceBands(market, oraclePriceData) {
+    const maxPercentDiff = market.marginRatioInitial - market.marginRatioMaintenance;
+    const offset = oraclePriceData.price
+        .mul(new anchor_1.BN(maxPercentDiff))
+        .div(numericConstants_1.MARGIN_PRECISION);
+    (0, assert_1.assert)(offset.gte(numericConstants_1.ZERO));
+    return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
+exports.oraclePriceBands = oraclePriceBands;
+function getMaxConfidenceIntervalMultiplier(market) {
+    let maxConfidenceIntervalMultiplier;
+    if ((0, types_1.isVariant)(market.contractTier, 'a')) {
+        maxConfidenceIntervalMultiplier = new anchor_1.BN(1);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'b')) {
+        maxConfidenceIntervalMultiplier = new anchor_1.BN(1);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'c')) {
+        maxConfidenceIntervalMultiplier = new anchor_1.BN(2);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'speculative')) {
+        maxConfidenceIntervalMultiplier = new anchor_1.BN(10);
+    }
+    else {
+        maxConfidenceIntervalMultiplier = new anchor_1.BN(50);
+    }
+    return maxConfidenceIntervalMultiplier;
+}
+exports.getMaxConfidenceIntervalMultiplier = getMaxConfidenceIntervalMultiplier;
+function getOracleValidity(market, oraclePriceData, oracleGuardRails, slot, oracleStalenessBuffer = numericConstants_1.FIVE) {
+    const isNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
+    const isTooVolatile = anchor_1.BN.max(oraclePriceData.price, market.amm.historicalOracleData.lastOraclePriceTwap)
+        .div(anchor_1.BN.max(numericConstants_1.ONE, anchor_1.BN.min(oraclePriceData.price, market.amm.historicalOracleData.lastOraclePriceTwap)))
+        .gt(oracleGuardRails.validity.tooVolatileRatio);
+    const confPctOfPrice = oraclePriceData.confidence
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(oraclePriceData.price);
+    const isConfTooLarge = confPctOfPrice.gt(oracleGuardRails.validity.confidenceIntervalMaxSize.mul(getMaxConfidenceIntervalMultiplier(market)));
+    const oracleDelay = slot.sub(oraclePriceData.slot).sub(oracleStalenessBuffer);
+    let isStaleForAmmImmediate = true;
+    if (market.amm.oracleSlotDelayOverride != 0) {
+        isStaleForAmmImmediate = oracleDelay.gt(anchor_1.BN.max(new anchor_1.BN(market.amm.oracleSlotDelayOverride), numericConstants_1.ZERO));
+    }
+    let isStaleForAmmLowRisk = false;
+    if (market.amm.oracleLowRiskSlotDelayOverride != 0) {
+        isStaleForAmmLowRisk = oracleDelay.gt(anchor_1.BN.max(new anchor_1.BN(market.amm.oracleLowRiskSlotDelayOverride), numericConstants_1.ZERO));
+    }
+    else {
+        isStaleForAmmLowRisk = oracleDelay.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
+    }
+    let isStaleForMargin = oracleDelay.gt(new anchor_1.BN(oracleGuardRails.validity.slotsBeforeStaleForMargin));
+    if ((0, types_1.isVariant)(market.amm.oracleSource, 'pythLazerStableCoin')) {
+        isStaleForMargin = oracleDelay.gt(new anchor_1.BN(oracleGuardRails.validity.slotsBeforeStaleForMargin).muln(3));
+    }
+    if (isNonPositive) {
+        return types_1.OracleValidity.NonPositive;
+    }
+    else if (isTooVolatile) {
+        return types_1.OracleValidity.TooVolatile;
+    }
+    else if (isConfTooLarge) {
+        return types_1.OracleValidity.TooUncertain;
+    }
+    else if (isStaleForMargin) {
+        return types_1.OracleValidity.StaleForMargin;
+    }
+    else if (!oraclePriceData.hasSufficientNumberOfDataPoints) {
+        return types_1.OracleValidity.InsufficientDataPoints;
+    }
+    else if (isStaleForAmmLowRisk) {
+        return types_1.OracleValidity.StaleForAMMLowRisk;
+    }
+    else if (isStaleForAmmImmediate) {
+        return types_1.OracleValidity.isStaleForAmmImmediate;
+    }
+    else {
+        return types_1.OracleValidity.Valid;
+    }
+}
+exports.getOracleValidity = getOracleValidity;
+function isOracleValid(market, oraclePriceData, oracleGuardRails, slot) {
+    // checks if oracle is valid for an AMM only fill
+    const amm = market.amm;
+    const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
+    const isOraclePriceTooVolatile = oraclePriceData.price
+        .div(anchor_1.BN.max(numericConstants_1.ONE, amm.historicalOracleData.lastOraclePriceTwap))
+        .gt(oracleGuardRails.validity.tooVolatileRatio) ||
+        amm.historicalOracleData.lastOraclePriceTwap
+            .div(anchor_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
+            .gt(oracleGuardRails.validity.tooVolatileRatio);
+    const maxConfidenceIntervalMultiplier = getMaxConfidenceIntervalMultiplier(market);
+    const isConfidenceTooLarge = anchor_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(oraclePriceData.price)
+        .gt(oracleGuardRails.validity.confidenceIntervalMaxSize.mul(maxConfidenceIntervalMultiplier));
+    const oracleIsStale = new anchor_1.BN(slot)
+        .sub(oraclePriceData.slot)
+        .gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
+    return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
+        oracleIsStale ||
+        isOraclePriceNonPositive ||
+        isOraclePriceTooVolatile ||
+        isConfidenceTooLarge);
+}
+exports.isOracleValid = isOracleValid;
+function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails) {
+    const oracleSpreadPct = oraclePriceData.price
+        .sub(amm.historicalOracleData.lastOraclePriceTwap5Min)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(amm.historicalOracleData.lastOraclePriceTwap5Min);
+    const maxDivergence = anchor_1.BN.max(oracleGuardRails.priceDivergence.oracleTwap5MinPercentDivergence, numericConstants_1.PERCENTAGE_PRECISION.div(new anchor_1.BN(2)));
+    const tooDivergent = oracleSpreadPct.abs().gte(maxDivergence);
+    return tooDivergent;
+}
+exports.isOracleTooDivergent = isOracleTooDivergent;
+function calculateLiveOracleTwap(histOracleData, oraclePriceData, now, period) {
+    let oracleTwap = undefined;
+    if (period.eq(numericConstants_1.FIVE_MINUTE)) {
+        oracleTwap = histOracleData.lastOraclePriceTwap5Min;
+    }
+    else {
+        //todo: assumes its fundingPeriod (1hr)
+        // period = amm.fundingPeriod;
+        oracleTwap = histOracleData.lastOraclePriceTwap;
+    }
+    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ONE, now.sub(histOracleData.lastOraclePriceTwapTs));
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, period.sub(sinceLastUpdate));
+    const clampRange = oracleTwap.div(new anchor_1.BN(3));
+    const clampedOraclePrice = anchor_1.BN.min(oracleTwap.add(clampRange), anchor_1.BN.max(oraclePriceData.price, oracleTwap.sub(clampRange)));
+    const newOracleTwap = oracleTwap
+        .mul(sinceStart)
+        .add(clampedOraclePrice.mul(sinceLastUpdate))
+        .div(sinceStart.add(sinceLastUpdate));
+    return newOracleTwap;
+}
+exports.calculateLiveOracleTwap = calculateLiveOracleTwap;
+function calculateLiveOracleStd(amm, oraclePriceData, now) {
+    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+    const liveOracleTwap = calculateLiveOracleTwap(amm.historicalOracleData, oraclePriceData, now, amm.fundingPeriod);
+    const liveOracleTwap5MIN = calculateLiveOracleTwap(amm.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE);
+    const priceDeltaVsTwap = anchor_1.BN.max(oraclePriceData.price.sub(liveOracleTwap).abs(), oraclePriceData.price.sub(liveOracleTwap5MIN).abs());
+    const oracleStd = priceDeltaVsTwap.add(amm.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate)));
+    return oracleStd;
+}
+exports.calculateLiveOracleStd = calculateLiveOracleStd;
+function getNewOracleConfPct(amm, oraclePriceData, reservePrice, now) {
+    const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
+    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ZERO, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
+    let lowerBoundConfPct = amm.lastOracleConfPct;
+    if (sinceLastUpdate.gt(numericConstants_1.ZERO)) {
+        const lowerBoundConfDivisor = anchor_1.BN.max(new anchor_1.BN(21).sub(sinceLastUpdate), new anchor_1.BN(5));
+        lowerBoundConfPct = amm.lastOracleConfPct.sub(amm.lastOracleConfPct.div(lowerBoundConfDivisor));
+    }
+    const confIntervalPct = confInterval
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(reservePrice);
+    const confIntervalPctResult = anchor_1.BN.max(confIntervalPct, lowerBoundConfPct);
+    return confIntervalPctResult;
+}
+exports.getNewOracleConfPct = getNewOracleConfPct;
+function trimVaaSignatures(vaa, n = 3) {
+    const currentNumSignatures = vaa[5];
+    if (n > currentNumSignatures) {
+        throw new Error("Resulting VAA can't have more signatures than the original VAA");
+    }
+    const trimmedVaa = Buffer.concat([
+        vaa.subarray(0, 6 + n * 66),
+        vaa.subarray(6 + currentNumSignatures * 66),
+    ]);
+    trimmedVaa[5] = n;
+    return trimmedVaa;
+}
+exports.trimVaaSignatures = trimVaaSignatures;
+function getMultipleBetweenOracleSources(firstOracleSource, secondOracleSource) {
+    if ((0, types_1.isOneOfVariant)(firstOracleSource, [
+        'pythPull',
+        'pyth1KPull',
+        'pyth1MPull',
+        'pythStableCoinPull',
+    ]) ||
+        (0, types_1.isOneOfVariant)(secondOracleSource, [
+            'pythPull',
+            'pyth1KPull',
+            'pyth1MPull',
+            'pythStableCoinPull',
+        ])) {
+        throw new Error('Pyth pull oracle support has been removed from the SDK');
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer1M')) {
+        return { numerator: new anchor_1.BN(1000000), denominator: new anchor_1.BN(1) };
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer1K')) {
+        return { numerator: new anchor_1.BN(1000), denominator: new anchor_1.BN(1) };
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer1M') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer')) {
+        return { numerator: new anchor_1.BN(1), denominator: new anchor_1.BN(1000000) };
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer1K') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer')) {
+        return { numerator: new anchor_1.BN(1), denominator: new anchor_1.BN(1000) };
+    }
+    return { numerator: new anchor_1.BN(1), denominator: new anchor_1.BN(1) };
+}
+exports.getMultipleBetweenOracleSources = getMultipleBetweenOracleSources;

package/lib/node/math/orders.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="bn.js" />
+import { User } from '../user';
+import { PerpMarketAccount, AMM, Order, PositionDirection, MarketTypeStr, StateAccount } from '../types';
+import { BN } from '../isomorphic/anchor';
+import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
+export declare function isOrderRiskIncreasing(user: User, order: Order): boolean;
+export declare function isOrderRiskIncreasingInSameDirection(user: User, order: Order): boolean;
+export declare function isOrderReduceOnly(user: User, order: Order): boolean;
+export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
+export declare function standardizePrice(price: BN, tickSize: BN, direction: PositionDirection): BN;
+export declare function getLimitPrice<T extends MarketTypeStr>(order: Order, oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData, slot: number, fallbackPrice?: BN): BN | undefined;
+export declare function hasLimitPrice(order: Order, slot: number): boolean;
+export declare function hasAuctionPrice(order: Order, slot: number): boolean;
+export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, slot: number, ts: number, state: StateAccount): boolean;
+export declare function isLowRiskForAmm(order: Order, mmOraclePriceData: MMOraclePriceData, isLiquidation?: boolean): boolean;
+export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, slot: number): BN;
+export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, amm: AMM, limitPrice: BN, mmOraclePriceData: MMOraclePriceData): BN;
+export declare function isOrderExpired(order: Order, ts: number, enforceBuffer?: boolean, bufferSeconds?: number): boolean;
+export declare function isMarketOrder(order: Order): boolean;
+export declare function isLimitOrder(order: Order): boolean;
+export declare function mustBeTriggered(order: Order): boolean;
+export declare function isTriggered(order: Order): boolean;
+export declare function isRestingLimitOrder(order: Order, slot: number): boolean;
+export declare function isTakingOrder(order: Order, slot: number): boolean;
+export declare function isSignedMsgOrder(order: Order): boolean;
+export declare function hasBuilder(order: Order): boolean;
+export declare function calculateOrderBaseAssetAmount(order: Order, existingBaseAssetAmount: BN): BN;
+/**
+ * Invert the size-premium liability weight: given a target margin ratio (liability weight),
+ * return the max `size` (AMM_RESERVE_PRECISION units) that still yields <= target.
+ *
+ * Returns:
+ * - BN size (>=0) if bounded
+ * - null if impossible (target < liabilityWeight) OR imfFactor == 0 (unbounded)
+ */
+export declare function maxSizeForTargetLiabilityWeightBN(target: BN, imfFactor: BN, liabilityWeight: BN, market: PerpMarketAccount): BN | null;
+//# sourceMappingURL=orders.d.ts.map

package/lib/node/math/orders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../src/math/orders.ts"],"names":[],"mappings":"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"}

package/lib/node/math/orders.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxSizeForTargetLiabilityWeightBN = exports.calculateOrderBaseAssetAmount = exports.hasBuilder = exports.isSignedMsgOrder = exports.isTakingOrder = exports.isRestingLimitOrder = exports.isTriggered = exports.mustBeTriggered = exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isLowRiskForAmm = exports.isFillableByVAMM = exports.hasAuctionPrice = exports.hasLimitPrice = exports.getLimitPrice = exports.standardizePrice = 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("../isomorphic/anchor");
+const auction_1 = require("./auction");
+const amm_1 = require("./amm");
+const margin_1 = require("./margin");
+function isOrderRiskIncreasing(user, order) {
+    if (!(0, types_1.isVariant)(order.status, 'open')) {
+        return false;
+    }
+    const position = user.getPerpPosition(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;
+    }
+    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 (!(0, types_1.isVariant)(order.status, 'open')) {
+        return false;
+    }
+    const position = user.getPerpPosition(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, 'open')) {
+        return false;
+    }
+    const position = user.getPerpPosition(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) {
+    const remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function standardizePrice(price, tickSize, direction) {
+    if (price.eq(numericConstants_1.ZERO)) {
+        console.log('price is zero');
+        return price;
+    }
+    const remainder = price.mod(tickSize);
+    if (remainder.eq(numericConstants_1.ZERO)) {
+        return price;
+    }
+    if ((0, types_1.isVariant)(direction, 'long')) {
+        return price.sub(remainder);
+    }
+    else {
+        return price.add(tickSize).sub(remainder);
+    }
+}
+exports.standardizePrice = standardizePrice;
+function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
+    if (hasAuctionPrice(order, slot)) {
+        return (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
+    }
+    else if (order.oraclePriceOffset !== 0) {
+        return anchor_1.BN.max(oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset)), numericConstants_1.ONE);
+    }
+    else if (order.price.eq(numericConstants_1.ZERO)) {
+        return fallbackPrice;
+    }
+    else {
+        return order.price;
+    }
+}
+exports.getLimitPrice = getLimitPrice;
+function hasLimitPrice(order, slot) {
+    return (order.price.gt(numericConstants_1.ZERO) ||
+        order.oraclePriceOffset != 0 ||
+        !(0, auction_1.isAuctionComplete)(order, slot));
+}
+exports.hasLimitPrice = hasLimitPrice;
+function hasAuctionPrice(order, slot) {
+    return (!(0, auction_1.isAuctionComplete)(order, slot) &&
+        (!order.auctionStartPrice.eq(numericConstants_1.ZERO) || !order.auctionEndPrice.eq(numericConstants_1.ZERO)));
+}
+exports.hasAuctionPrice = hasAuctionPrice;
+function isFillableByVAMM(order, market, mmOraclePriceData, slot, ts, state) {
+    return (((0, auction_1.isFallbackAvailableLiquiditySource)(order, mmOraclePriceData, slot, state, market) &&
+        calculateBaseAssetAmountForAmmToFulfill(order, market, mmOraclePriceData, slot).gt(numericConstants_1.ZERO)) ||
+        isOrderExpired(order, ts));
+}
+exports.isFillableByVAMM = isFillableByVAMM;
+function isLowRiskForAmm(order, mmOraclePriceData, isLiquidation) {
+    if ((0, types_1.isVariant)(order.marketType, 'spot')) {
+        return false;
+    }
+    const orderOlderThanOracleDelay = new anchor_1.BN(order.slot).lte(mmOraclePriceData.slot);
+    return (orderOlderThanOracleDelay ||
+        isLiquidation ||
+        (order.bitFlags & types_1.OrderBitFlag.SafeTriggerOrder) !== 0);
+}
+exports.isLowRiskForAmm = isLowRiskForAmm;
+function calculateBaseAssetAmountForAmmToFulfill(order, market, mmOraclePriceData, slot) {
+    if (mustBeTriggered(order) && !isTriggered(order)) {
+        return numericConstants_1.ZERO;
+    }
+    const limitPrice = getLimitPrice(order, mmOraclePriceData, slot);
+    let baseAssetAmount;
+    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, mmOraclePriceData);
+    if (limitPrice !== undefined) {
+        baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, limitPrice, mmOraclePriceData);
+    }
+    else {
+        baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    }
+    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, order.direction);
+    return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, mmOraclePriceData) {
+    const adjustedLimitPrice = (0, types_1.isVariant)(order.direction, 'long')
+        ? limitPrice.sub(amm.orderTickSize)
+        : limitPrice.add(amm.orderTickSize);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, adjustedLimitPrice, order.direction, mmOraclePriceData);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, amm.orderStepSize);
+    // Check that directions are the same
+    const sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    const baseAssetAmountUnfilled = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    return baseAssetAmount.gt(baseAssetAmountUnfilled)
+        ? baseAssetAmountUnfilled
+        : 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, ts, enforceBuffer = false, bufferSeconds = 15) {
+    if (mustBeTriggered(order) ||
+        !(0, types_1.isVariant)(order.status, 'open') ||
+        order.maxTs.eq(numericConstants_1.ZERO)) {
+        return false;
+    }
+    let maxTs;
+    if (enforceBuffer && isLimitOrder(order)) {
+        maxTs = order.maxTs.addn(bufferSeconds);
+    }
+    else {
+        maxTs = order.maxTs;
+    }
+    return new anchor_1.BN(ts).gt(maxTs);
+}
+exports.isOrderExpired = isOrderExpired;
+function isMarketOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle']);
+}
+exports.isMarketOrder = isMarketOrder;
+function isLimitOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
+}
+exports.isLimitOrder = isLimitOrder;
+function mustBeTriggered(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']);
+}
+exports.mustBeTriggered = mustBeTriggered;
+function isTriggered(order) {
+    return (0, types_1.isOneOfVariant)(order.triggerCondition, [
+        'triggeredAbove',
+        'triggeredBelow',
+    ]);
+}
+exports.isTriggered = isTriggered;
+function isRestingLimitOrder(order, slot) {
+    if (!isLimitOrder(order)) {
+        return false;
+    }
+    return order.postOnly || (0, auction_1.isAuctionComplete)(order, slot);
+}
+exports.isRestingLimitOrder = isRestingLimitOrder;
+function isTakingOrder(order, slot) {
+    return isMarketOrder(order) || !isRestingLimitOrder(order, slot);
+}
+exports.isTakingOrder = isTakingOrder;
+const FLAG_IS_SIGNED_MSG = 0x01;
+function isSignedMsgOrder(order) {
+    return (order.bitFlags & FLAG_IS_SIGNED_MSG) !== 0;
+}
+exports.isSignedMsgOrder = isSignedMsgOrder;
+const FLAG_HAS_BUILDER = 0x10;
+function hasBuilder(order) {
+    return (order.bitFlags & FLAG_HAS_BUILDER) !== 0;
+}
+exports.hasBuilder = hasBuilder;
+function calculateOrderBaseAssetAmount(order, existingBaseAssetAmount) {
+    if (!order.reduceOnly) {
+        return order.baseAssetAmount;
+    }
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        return anchor_1.BN.min(anchor_1.BN.min(existingBaseAssetAmount, numericConstants_1.ZERO).abs(), order.baseAssetAmount);
+    }
+    else {
+        return anchor_1.BN.min(anchor_1.BN.max(existingBaseAssetAmount, numericConstants_1.ZERO), order.baseAssetAmount);
+    }
+}
+exports.calculateOrderBaseAssetAmount = calculateOrderBaseAssetAmount;
+// ---------- inverse ----------
+/**
+ * Invert the size-premium liability weight: given a target margin ratio (liability weight),
+ * return the max `size` (AMM_RESERVE_PRECISION units) that still yields <= target.
+ *
+ * Returns:
+ * - BN size (>=0) if bounded
+ * - null if impossible (target < liabilityWeight) OR imfFactor == 0 (unbounded)
+ */
+function maxSizeForTargetLiabilityWeightBN(target, imfFactor, liabilityWeight, market) {
+    if (target.lt(liabilityWeight))
+        return null;
+    if (imfFactor.isZero())
+        return null;
+    const base = liabilityWeight.muln(4).divn(5);
+    const denom = new anchor_1.BN(100000)
+        .mul(numericConstants_1.SPOT_MARKET_IMF_PRECISION)
+        .div(numericConstants_1.MARGIN_PRECISION);
+    if (denom.isZero())
+        throw new Error('denom=0: bad precision/spotImfPrecision');
+    const allowedInc = target.gt(base) ? target.sub(base) : numericConstants_1.ZERO;
+    const maxSqrt = allowedInc.mul(denom).div(imfFactor);
+    if (maxSqrt.lte(numericConstants_1.ZERO)) {
+        const fitsZero = (0, margin_1.calculateSizePremiumLiabilityWeight)(numericConstants_1.ZERO, imfFactor, liabilityWeight, numericConstants_1.MARGIN_PRECISION).lte(target);
+        return fitsZero ? numericConstants_1.ZERO : null;
+    }
+    let hi = maxSqrt.mul(maxSqrt).sub(numericConstants_1.ONE).divn(10);
+    if (hi.isNeg())
+        hi = numericConstants_1.ZERO;
+    let lo = numericConstants_1.ZERO;
+    while (lo.lt(hi)) {
+        const mid = lo.add(hi).add(numericConstants_1.ONE).divn(2); // upper mid to prevent infinite loop
+        if ((0, margin_1.calculateSizePremiumLiabilityWeight)(mid, imfFactor, liabilityWeight, numericConstants_1.MARGIN_PRECISION).lte(target)) {
+            lo = mid;
+        }
+        else {
+            hi = mid.sub(numericConstants_1.ONE);
+        }
+    }
+    // cap at max OI
+    const maxOpenInterest = market.amm.maxOpenInterest;
+    if (lo.gt(maxOpenInterest)) {
+        return maxOpenInterest;
+    }
+    return lo;
+}
+exports.maxSizeForTargetLiabilityWeightBN = maxSizeForTargetLiabilityWeightBN;

package/lib/node/math/position.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="bn.js" />
+import { BN } from '../isomorphic/anchor';
+import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
+import { PerpMarketAccount, PositionDirection, PerpPosition, SpotMarketAccount } from '../types';
+/**
+ * calculateBaseAssetValue
+ * = market value of closing entire position
+ * @param market
+ * @param userPosition
+ * @param oraclePriceData
+ * @returns Base Asset Value. : Precision QUOTE_PRECISION
+ */
+export declare function calculateBaseAssetValue(market: PerpMarketAccount, userPosition: PerpPosition, mmOraclePriceData: MMOraclePriceData, useSpread?: boolean, skipUpdate?: boolean, latestSlot?: BN): BN;
+/**
+ * calculatePositionPNL
+ * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
+ * @param market
+ * @param PerpPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+export declare function calculatePositionPNL(market: PerpMarketAccount, perpPosition: PerpPosition, withFunding: boolean, oraclePriceData: Pick<OraclePriceData, 'price'>): BN;
+export declare function calculateClaimablePnl(market: PerpMarketAccount, spotMarket: SpotMarketAccount, perpPosition: PerpPosition, oraclePriceData: Pick<OraclePriceData, 'price'>): BN;
+/**
+ * Returns total fees and funding pnl for a position
+ *
+ * @param market
+ * @param PerpPosition
+ * @param includeUnsettled include unsettled funding in return value (default: true)
+ * @returns — // QUOTE_PRECISION
+ */
+export declare function calculateFeesAndFundingPnl(market: PerpMarketAccount, perpPosition: PerpPosition, includeUnsettled?: boolean): BN;
+/**
+ * Returns unsettled funding pnl for the position
+ *
+ * To calculate all fees and funding pnl including settled, use calculateFeesAndFundingPnl
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+export declare function calculateUnsettledFundingPnl(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
+/**
+ * @deprecated use calculateUnsettledFundingPnl or calculateFeesAndFundingPnl instead
+ */
+export declare function calculatePositionFundingPNL(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
+export declare function positionIsAvailable(position: PerpPosition): boolean;
+export declare function positionIsBeingLiquidated(position: PerpPosition): boolean;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export declare function calculateBreakEvenPrice(userPosition: PerpPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+export declare function calculateEntryPrice(userPosition: PerpPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+export declare function calculateCostBasis(userPosition: PerpPosition, includeSettledPnl?: boolean): BN;
+export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;
+export declare function positionCurrentDirection(userPosition: PerpPosition): PositionDirection;
+export declare function isEmptyPosition(userPosition: PerpPosition): boolean;
+export declare function hasOpenOrders(position: PerpPosition): boolean;
+//# sourceMappingURL=position.d.ts.map

package/lib/node/math/position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../src/math/position.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAU1C,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EACN,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EAEjB,MAAM,UAAU,CAAC;AAUlB;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,iBAAiB,EACzB,YAAY,EAAE,YAAY,EAC1B,iBAAiB,EAAE,iBAAiB,EACpC,SAAS,UAAO,EAChB,UAAU,UAAQ,EAClB,UAAU,CAAC,EAAE,EAAE,GACb,EAAE,CAmDJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,iBAAiB,EACzB,YAAY,EAAE,YAAY,EAC1B,WAAW,SAAQ,EACnB,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,GAC7C,EAAE,CAwBJ;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,iBAAiB,EAC7B,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,GAC7C,EAAE,CAyBJ;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,iBAAiB,EACzB,YAAY,EAAE,YAAY,EAC1B,gBAAgB,UAAO,GACrB,EAAE,CAeJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,iBAAiB,EACzB,YAAY,EAAE,YAAY,GACxB,EAAE,CAoBJ;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAC1C,MAAM,EAAE,iBAAiB,EACzB,YAAY,EAAE,YAAY,GACxB,EAAE,CAEJ;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAQnE;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAMzE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,YAAY,GAAG,EAAE,CAUtE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,EAAE,CAUlE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,YAAY,EAAE,YAAY,EAC1B,iBAAiB,UAAQ,GACvB,EAAE,CAWJ;AAED,wBAAgB,oBAAoB,CACnC,YAAY,EAAE,YAAY,GACxB,iBAAiB,CAInB;AAED,wBAAgB,wBAAwB,CACvC,YAAY,EAAE,YAAY,GACxB,iBAAiB,CAInB;AAED,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAEnE;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAM7D"}