@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/lib/math/funding.js

@@ -3,7 +3,8 @@ 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");
+const types_1 = require("../types");
+const amm_1 = require("./amm");
 /**
  *
  * @param market
@@ -19,7 +20,7 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     const secondsInHour = new anchor_1.BN(3600);
     const hoursInDay = new anchor_1.BN(24);
     const ONE = new anchor_1.BN(1);
-    if (!market.initialized) {
+    if ((0, types_1.isVariant)(market.status, 'uninitialized')) {
         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);
@@ -31,15 +32,16 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     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 = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+    const [bid, ask] = (0, amm_1.calculateBidAskPrice)(market.amm, oraclePriceData);
+    const baseAssetPriceWithMantissa = bid.add(ask).div(new anchor_1.BN(2));
     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 lastOracleTwapWithMantissa = market.amm.historicalOracleData.lastOraclePriceTwap;
+    const lastOraclePriceTwapTs = market.amm.historicalOracleData.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))));
@@ -50,11 +52,11 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
         const oracleLiveVsTwap = oraclePrice
             .sub(lastOracleTwapWithMantissa)
             .abs()
-            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(numericConstants_1.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)))) {
+        if (oracleLiveVsTwap.lte(numericConstants_1.PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
             oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
                 .mul(lastOracleTwapWithMantissa)
                 .add(timeSinceLastMarkChange.mul(oraclePrice))
@@ -67,7 +69,7 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
         .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
     const twapSpread = lastMarkTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
     const twapSpreadPct = twapSpread
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(new anchor_1.BN(100))
         .div(shrunkLastOracleTwapwithMantissa);
     const lowerboundEst = twapSpreadPct
@@ -81,7 +83,7 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     const interpRateQuote = twapSpreadPct
         .mul(periodAdjustment)
         .div(hoursInDay)
-        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
+        .div(numericConstants_1.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));
@@ -89,9 +91,9 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     let cappedAltEst;
     let largerSide;
     let smallerSide;
-    if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-        largerSide = market.baseAssetAmountLong.abs();
-        smallerSide = market.baseAssetAmountShort.abs();
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())) {
+        largerSide = market.amm.baseAssetAmountLong.abs();
+        smallerSide = market.amm.baseAssetAmountShort.abs();
         if (twapSpread.gt(new anchor_1.BN(0))) {
             return [
                 markTwapWithMantissa,
@@ -102,9 +104,9 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
             ];
         }
     }
-    else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
-        largerSide = market.baseAssetAmountShort.abs();
-        smallerSide = market.baseAssetAmountLong.abs();
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())) {
+        largerSide = market.amm.baseAssetAmountShort.abs();
+        smallerSide = market.amm.baseAssetAmountLong.abs();
         if (twapSpread.lt(new anchor_1.BN(0))) {
             return [
                 markTwapWithMantissa,
@@ -128,11 +130,11 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
         // 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.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(numericConstants_1.PRICE_PRECISION)
             .mul(new anchor_1.BN(100))
             .div(oracleTwapWithMantissa)
             .mul(periodAdjustment);
@@ -183,10 +185,10 @@ exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
  */
 async function calculateLongShortFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
     const [_1, _2, _, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-    if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
         return [cappedAltEst, interpEst];
     }
-    else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)) {
         return [interpEst, cappedAltEst];
     }
     else {
@@ -203,10 +205,10 @@ exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
  */
 async function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
     const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-    if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())) {
         return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
     }
-    else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())) {
         return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
     }
     else {

package/lib/math/insurance.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '../index';
+export declare function stakeAmountToShares(amount: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;
+export declare function unstakeSharesToAmount(nShares: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;

package/lib/math/insurance.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unstakeSharesToAmount = exports.stakeAmountToShares = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+function stakeAmountToShares(amount, totalIfShares, insuranceFundVaultBalance) {
+    let nShares;
+    if (insuranceFundVaultBalance.gt(numericConstants_1.ZERO)) {
+        nShares = amount.mul(totalIfShares).div(insuranceFundVaultBalance);
+    }
+    else {
+        nShares = amount;
+    }
+    return nShares;
+}
+exports.stakeAmountToShares = stakeAmountToShares;
+function unstakeSharesToAmount(nShares, totalIfShares, insuranceFundVaultBalance) {
+    let amount;
+    if (totalIfShares.gt(numericConstants_1.ZERO)) {
+        amount = index_1.BN.max(numericConstants_1.ZERO, nShares.mul(insuranceFundVaultBalance).div(totalIfShares));
+    }
+    else {
+        amount = numericConstants_1.ZERO;
+    }
+    return amount;
+}
+exports.unstakeSharesToAmount = unstakeSharesToAmount;

package/lib/math/margin.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { PerpMarketAccount, PerpPosition } from '..';
+export declare function calculateSizePremiumLiabilityWeight(size: BN, // AMM_RESERVE_PRECISION
+imfFactor: BN, liabilityWeight: BN, precision: BN): BN;
+export declare function calculateSizeDiscountAssetWeight(size: BN, // AMM_RESERVE_PRECISION
+imfFactor: BN, assetWeight: BN): BN;
+export declare function calculateOraclePriceForPerpMargin(perpPosition: PerpPosition, market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBaseAssetValueWithOracle(market: PerpMarketAccount, perpPosition: PerpPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateWorstCaseBaseAssetAmount(perpPosition: PerpPosition): BN;

package/lib/math/margin.js

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

package/lib/math/market.d.ts

@@ -1,28 +1,33 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection, MarginCategory, SpotMarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 /**
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-export declare function calculateMarkPrice(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateReservePrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 /**
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
-export declare function calculateBidPrice(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBidPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 /**
  * Calculates market ask price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
-export declare function calculateAskPrice(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
-export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: MarketAccount): MarketAccount;
-export declare function calculateMarkOracleSpread(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateAskPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: PerpMarketAccount): PerpMarketAccount;
+export declare function calculateOracleReserveSpread(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarketMarginRatio(market: PerpMarketAccount, size: BN, marginCategory: MarginCategory): number;
+export declare function calculateUnrealizedAssetWeight(market: PerpMarketAccount, quoteSpotMarket: SpotMarketAccount, unrealizedPnl: BN, marginCategory: MarginCategory, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarketAvailablePNL(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;
+export declare function calculateNetUserPnl(perpMarket: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateNetUserPnlImbalance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount, oraclePriceData: OraclePriceData): BN;

package/lib/math/market.js

@@ -1,24 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateOracleReserveSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
+const anchor_1 = require("@project-serum/anchor");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const margin_1 = require("./margin");
+const numericConstants_1 = require("../constants/numericConstants");
+const spotBalance_1 = require("./spotBalance");
 /**
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-function calculateMarkPrice(market, oraclePriceData) {
+function calculateReservePrice(market, oraclePriceData) {
     const newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
     return (0, amm_1.calculatePrice)(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
 }
-exports.calculateMarkPrice = calculateMarkPrice;
+exports.calculateReservePrice = calculateReservePrice;
 /**
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
 function calculateBidPrice(market, oraclePriceData) {
     const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
@@ -29,7 +33,7 @@ exports.calculateBidPrice = calculateBidPrice;
  * Calculates market ask price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
 function calculateAskPrice(market, oraclePriceData) {
     const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
@@ -46,12 +50,68 @@ function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
     return newMarket;
 }
 exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
-function calculateMarkOracleSpread(market, oraclePriceData) {
-    const markPrice = calculateMarkPrice(market, oraclePriceData);
-    return calculateOracleSpread(markPrice, oraclePriceData);
+function calculateOracleReserveSpread(market, oraclePriceData) {
+    const reservePrice = calculateReservePrice(market, oraclePriceData);
+    return calculateOracleSpread(reservePrice, oraclePriceData);
 }
-exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
+exports.calculateOracleReserveSpread = calculateOracleReserveSpread;
 function calculateOracleSpread(price, oraclePriceData) {
     return price.sub(oraclePriceData.price);
 }
 exports.calculateOracleSpread = calculateOracleSpread;
+function calculateMarketMarginRatio(market, size, marginCategory) {
+    let marginRatio;
+    switch (marginCategory) {
+        case 'Initial':
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            break;
+        case 'Maintenance':
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioMaintenance), numericConstants_1.MARGIN_PRECISION).toNumber();
+            break;
+    }
+    return marginRatio;
+}
+exports.calculateMarketMarginRatio = calculateMarketMarginRatio;
+function calculateUnrealizedAssetWeight(market, quoteSpotMarket, unrealizedPnl, marginCategory, oraclePriceData) {
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = new anchor_1.BN(market.unrealizedPnlInitialAssetWeight);
+            if (market.unrealizedPnlMaxImbalance.gt(numericConstants_1.ZERO)) {
+                const netUnsettledPnl = calculateNetUserPnlImbalance(market, quoteSpotMarket, oraclePriceData);
+                if (netUnsettledPnl.gt(market.unrealizedPnlMaxImbalance)) {
+                    assetWeight = assetWeight
+                        .mul(market.unrealizedPnlMaxImbalance)
+                        .div(netUnsettledPnl);
+                }
+            }
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, new anchor_1.BN(market.unrealizedPnlImfFactor), assetWeight);
+            break;
+        case 'Maintenance':
+            assetWeight = new anchor_1.BN(market.unrealizedPnlMaintenanceAssetWeight);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateUnrealizedAssetWeight = calculateUnrealizedAssetWeight;
+function calculateMarketAvailablePNL(perpMarket, spotMarket) {
+    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+}
+exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
+function calculateNetUserPnl(perpMarket, oraclePriceData) {
+    const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BASE_PRECISION)
+        .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    const netUserCostBasis = perpMarket.amm.quoteAssetAmount;
+    const netUserPnl = netUserPositionValue.add(netUserCostBasis);
+    return netUserPnl;
+}
+exports.calculateNetUserPnl = calculateNetUserPnl;
+function calculateNetUserPnlImbalance(perpMarket, spotMarket, oraclePriceData) {
+    const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
+    const pnlPool = (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const imbalance = netUserPnl.sub(pnlPool);
+    return imbalance;
+}
+exports.calculateNetUserPnlImbalance = calculateNetUserPnlImbalance;

package/lib/math/oracles.d.ts

@@ -1,3 +1,7 @@
+/// <reference types="bn.js" />
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
+import { BN, PerpMarketAccount } from '../index';
+export declare function oraclePriceBands(market: PerpMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];
 export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
+export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, now: BN): boolean;

package/lib/math/oracles.js

@@ -1,22 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleValid = void 0;
+exports.isOracleTooDivergent = exports.isOracleValid = exports.oraclePriceBands = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const index_1 = require("../index");
+const assert_1 = require("../assert/assert");
+function oraclePriceBands(market, oraclePriceData) {
+    const maxPercentDiff = market.marginRatioInitial - market.marginRatioMaintenance;
+    const 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 isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price
-        .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
+        .div(index_1.BN.max(numericConstants_1.ONE, amm.historicalOracleData.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
-        amm.lastOraclePriceTwap
+        amm.historicalOracleData.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 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));
     const oracleIsStale = oraclePriceData.slot
         .sub(new index_1.BN(slot))
-        .gt(oracleGuardRails.validity.slotsBeforeStale);
+        .gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
     return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
         oracleIsStale ||
         isOraclePriceNonPositive ||
@@ -24,3 +36,19 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         isConfidenceTooLarge);
 }
 exports.isOracleValid = isOracleValid;
+function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
+    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, new index_1.BN(60 * 5).sub(sinceLastUpdate));
+    const oracleTwap5min = amm.historicalOracleData.lastOraclePriceTwap5Min
+        .mul(sinceStart)
+        .add(oraclePriceData.price)
+        .mul(sinceLastUpdate)
+        .div(sinceStart.add(sinceLastUpdate));
+    const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+    const oracleSpreadPct = oracleSpread.mul(numericConstants_1.PRICE_PRECISION).div(oracleTwap5min);
+    const tooDivergent = oracleSpreadPct
+        .abs()
+        .gte(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(oracleGuardRails.priceDivergence.markOracleDivergenceNumerator).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator));
+    return tooDivergent;
+}
+exports.isOracleTooDivergent = isOracleTooDivergent;

package/lib/math/orders.d.ts

@@ -1,10 +1,20 @@
 /// <reference types="bn.js" />
-import { ClearingHouseUser } from '../clearingHouseUser';
-import { MarketAccount, Order } from '../types';
+import { User } from '../user';
+import { PerpMarketAccount, Order } from '../types';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Order): boolean;
-export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouseUser, order: Order): boolean;
-export declare function isOrderReduceOnly(user: ClearingHouseUser, order: Order): boolean;
+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 getLimitPrice(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function getOptionalLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN | undefined;
+export declare function hasLimitPrice(order: Order, slot: number): boolean;
+export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, ts: number): boolean;
+export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, market: PerpMarketAccount, limitPrice: BN, oraclePriceData: OraclePriceData): BN;
+export declare function isOrderExpired(order: Order, ts: 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;