@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/lib/math/funding.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { MarketAccount } from '../types';
+import { PerpMarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 /**
  *
@@ -9,7 +9,7 @@ import { OraclePriceData } from '../oracles/types';
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateAllEstimatedFundingRate(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN, BN]>;
+export declare function calculateAllEstimatedFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN, BN]>;
 /**
  *
  * @param market
@@ -18,7 +18,7 @@ export declare function calculateAllEstimatedFundingRate(market: MarketAccount,
  * @param estimationMethod
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateEstimatedFundingRate(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN, estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'): Promise<BN>;
+export declare function calculateEstimatedFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN, estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'): Promise<BN>;
 /**
  *
  * @param market
@@ -26,7 +26,7 @@ export declare function calculateEstimatedFundingRate(market: MarketAccount, ora
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateLongShortFundingRate(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN]>;
+export declare function calculateLongShortFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN]>;
 /**
  *
  * @param market
@@ -34,10 +34,10 @@ export declare function calculateLongShortFundingRate(market: MarketAccount, ora
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateLongShortFundingRateAndLiveTwaps(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN]>;
+export declare function calculateLongShortFundingRateAndLiveTwaps(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN]>;
 /**
  *
  * @param market
  * @returns Estimated fee pool size
  */
-export declare function calculateFundingPool(market: MarketAccount): BN;
+export declare function calculateFundingPool(market: PerpMarketAccount): BN;

package/lib/math/funding.js

@@ -3,6 +3,7 @@ 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 types_1 = require("../types");
 const market_1 = require("./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,15 @@ 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 baseAssetPriceWithMantissa = (0, market_1.calculateReservePrice)(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 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 +51,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 +68,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 +82,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));
@@ -128,11 +129,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);

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,77 @@
+"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 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) {
+    return perpPosition.baseAssetAmount
+        .abs()
+        .mul(oraclePriceData.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,70 @@ 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, market.imfFactor, new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            break;
+        case 'Maintenance':
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, 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.unrealizedInitialAssetWeight);
+            if (market.unrealizedMaxImbalance.gt(numericConstants_1.ZERO)) {
+                const netUnsettledPnl = calculateNetUserPnlImbalance(market, quoteSpotMarket, oraclePriceData);
+                if (netUnsettledPnl.gt(market.unrealizedMaxImbalance)) {
+                    assetWeight = assetWeight
+                        .mul(market.unrealizedMaxImbalance)
+                        .div(netUnsettledPnl);
+                }
+            }
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, market.unrealizedImfFactor, assetWeight);
+            break;
+        case 'Maintenance':
+            assetWeight = new anchor_1.BN(market.unrealizedMaintenanceAssetWeight);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateUnrealizedAssetWeight = calculateUnrealizedAssetWeight;
+function calculateMarketAvailablePNL(perpMarket, spotMarket) {
+    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.balance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+}
+exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
+function calculateNetUserPnl(perpMarket, oraclePriceData) {
+    const netUserPositionValue = perpMarket.amm.netBaseAssetAmount
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BASE_PRECISION)
+        .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    const netUserCostBasis = perpMarket.amm.quoteAssetAmountLong
+        .add(perpMarket.amm.quoteAssetAmountShort)
+        .sub(perpMarket.amm.cumulativeSocialLoss);
+    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.balance, 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,14 @@
 /// <reference types="bn.js" />
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { Order } from '../types';
+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 standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
-export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number, perpMarket?: PerpMarketAccount): BN;
+export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: 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, slot: number): boolean;

package/lib/math/orders.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = 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");
+const amm_1 = require("./amm");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
@@ -77,13 +80,42 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
     return baseAssetAmount.sub(remainder);
 }
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, oraclePriceData, slot) {
+function getLimitPrice(order, oraclePriceData, slot, perpMarket) {
     let limitPrice;
     if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
         limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
     else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
-        limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+        if (!(0, auction_1.isAuctionComplete)(order, slot)) {
+            limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else {
+            if (perpMarket) {
+                if ((0, types_1.isVariant)(order.direction, 'long')) {
+                    const askPrice = (0, market_1.calculateAskPrice)(perpMarket, oraclePriceData);
+                    const delta = askPrice.div(new anchor_1.BN(perpMarket.amm.maxSlippageRatio));
+                    limitPrice = askPrice.add(delta);
+                }
+                else {
+                    const bidPrice = (0, market_1.calculateBidPrice)(perpMarket, oraclePriceData);
+                    const delta = bidPrice.div(new anchor_1.BN(perpMarket.amm.maxSlippageRatio));
+                    limitPrice = bidPrice.sub(delta);
+                }
+            }
+            else {
+                // check oracle validity?
+                const oraclePrice1Pct = oraclePriceData.price.div(new anchor_1.BN(100));
+                if ((0, types_1.isVariant)(order.direction, 'long')) {
+                    limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
+                }
+                else {
+                    limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
+                }
+            }
+        }
     }
     else {
         limitPrice = order.price;
@@ -91,3 +123,46 @@ function getLimitPrice(order, oraclePriceData, slot) {
     return limitPrice;
 }
 exports.getLimitPrice = getLimitPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot) {
+    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+        !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
+        isOrderExpired(order, slot));
+}
+exports.isFillableByVAMM = isFillableByVAMM;
+function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+        order.triggered === false) {
+        return numericConstants_1.ZERO;
+    }
+    const limitPrice = getLimitPrice(order, oraclePriceData, slot, market);
+    const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData);
+    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(market.amm, order.direction);
+    return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData) {
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
+    // Check that directions are the same
+    const sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    return baseAssetAmount.gt(order.baseAssetAmount)
+        ? order.baseAssetAmount
+        : baseAssetAmount;
+}
+exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
+function isSameDirection(firstDirection, secondDirection) {
+    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
+        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
+}
+function isOrderExpired(order, slot) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+        !(0, types_1.isVariant)(order.status, 'open') ||
+        order.timeInForce === 0) {
+        return false;
+    }
+    return new anchor_1.BN(slot).sub(order.slot).gt(new anchor_1.BN(order.timeInForce));
+}
+exports.isOrderExpired = isOrderExpired;