@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/browser/math/margin.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { DriftClient, 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;
+/**
+ * This is _not_ the same as liability value as for prediction markets, the liability for the short in prediction market is (1 - oracle price) * base
+ * See {@link calculatePerpLiabilityValue} to get the liabiltiy value
+ * @param market
+ * @param perpPosition
+ * @param oraclePriceData
+ * @param includeOpenOrders
+ */
+export declare function calculateBaseAssetValueWithOracle(market: PerpMarketAccount, perpPosition: PerpPosition, oraclePriceData: OraclePriceData, includeOpenOrders?: boolean): BN;
+export declare function calculateWorstCaseBaseAssetAmount(perpPosition: PerpPosition, perpMarket: PerpMarketAccount, oraclePrice: BN): BN;
+export declare function calculateWorstCasePerpLiabilityValue(perpPosition: PerpPosition, perpMarket: PerpMarketAccount, oraclePrice: BN): {
+    worstCaseBaseAssetAmount: BN;
+    worstCaseLiabilityValue: BN;
+};
+export declare function calculatePerpLiabilityValue(baseAssetAmount: BN, price: BN, isPredictionMarket: boolean): BN;
+/**
+ * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
+ * @param targetMarketIndex
+ * @param baseSize
+ * @returns
+ */
+export declare function calculateMarginUSDCRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, userMaxMarginRatio?: number, userHighLeverageMode?: boolean, entryPrice?: BN): BN;
+/**
+ * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
+ *
+ * Returns collateral required in the precision of the target collateral market.
+ */
+export declare function calculateCollateralDepositRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, collateralIndex: number, userMaxMarginRatio?: number, userHighLeverageMode?: boolean, estEntryPrice?: BN): BN;
+export declare function calculateCollateralValueOfDeposit(driftClient: DriftClient, collateralIndex: number, baseSize: BN): BN;
+export declare function calculateLiquidationPrice(freeCollateral: BN, freeCollateralDelta: BN, oraclePrice: BN): BN;

package/lib/browser/math/margin.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateLiquidationPrice = exports.calculateCollateralValueOfDeposit = exports.calculateCollateralDepositRequiredForTrade = exports.calculateMarginUSDCRequiredForTrade = exports.calculatePerpLiabilityValue = exports.calculateWorstCasePerpLiabilityValue = 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("@coral-xyz/anchor");
+const __1 = require("..");
+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.abs().mul(new anchor_1.BN(10)).add(new anchor_1.BN(1))); //1e9 -> 1e10 -> 1e5
+    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(new anchor_1.BN(5)));
+    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.abs().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;
+/**
+ * This is _not_ the same as liability value as for prediction markets, the liability for the short in prediction market is (1 - oracle price) * base
+ * See {@link calculatePerpLiabilityValue} to get the liabiltiy value
+ * @param market
+ * @param perpPosition
+ * @param oraclePriceData
+ * @param includeOpenOrders
+ */
+function calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData, includeOpenOrders = false) {
+    let price = oraclePriceData.price;
+    if ((0, types_1.isVariant)(market.status, 'settlement')) {
+        price = market.expiryPrice;
+    }
+    const baseAssetAmount = includeOpenOrders
+        ? calculateWorstCaseBaseAssetAmount(perpPosition, market, oraclePriceData.price)
+        : perpPosition.baseAssetAmount;
+    return baseAssetAmount.abs().mul(price).div(numericConstants_1.AMM_RESERVE_PRECISION);
+}
+exports.calculateBaseAssetValueWithOracle = calculateBaseAssetValueWithOracle;
+function calculateWorstCaseBaseAssetAmount(perpPosition, perpMarket, oraclePrice) {
+    return calculateWorstCasePerpLiabilityValue(perpPosition, perpMarket, oraclePrice).worstCaseBaseAssetAmount;
+}
+exports.calculateWorstCaseBaseAssetAmount = calculateWorstCaseBaseAssetAmount;
+function calculateWorstCasePerpLiabilityValue(perpPosition, perpMarket, oraclePrice) {
+    const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+    const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
+    const isPredictionMarket = (0, types_1.isVariant)(perpMarket.contractType, 'prediction');
+    const allBidsLiabilityValue = calculatePerpLiabilityValue(allBids, oraclePrice, isPredictionMarket);
+    const allAsksLiabilityValue = calculatePerpLiabilityValue(allAsks, oraclePrice, isPredictionMarket);
+    if (allAsksLiabilityValue.gte(allBidsLiabilityValue)) {
+        return {
+            worstCaseBaseAssetAmount: allAsks,
+            worstCaseLiabilityValue: allAsksLiabilityValue,
+        };
+    }
+    else {
+        return {
+            worstCaseBaseAssetAmount: allBids,
+            worstCaseLiabilityValue: allBidsLiabilityValue,
+        };
+    }
+}
+exports.calculateWorstCasePerpLiabilityValue = calculateWorstCasePerpLiabilityValue;
+function calculatePerpLiabilityValue(baseAssetAmount, price, isPredictionMarket) {
+    if (isPredictionMarket) {
+        if (baseAssetAmount.gt(numericConstants_1.ZERO)) {
+            return baseAssetAmount.mul(price).div(numericConstants_1.BASE_PRECISION);
+        }
+        else {
+            return baseAssetAmount
+                .abs()
+                .mul(numericConstants_1.MAX_PREDICTION_PRICE.sub(price))
+                .div(numericConstants_1.BASE_PRECISION);
+        }
+    }
+    else {
+        return baseAssetAmount.abs().mul(price).div(numericConstants_1.BASE_PRECISION);
+    }
+}
+exports.calculatePerpLiabilityValue = calculatePerpLiabilityValue;
+/**
+ * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
+ * @param targetMarketIndex
+ * @param baseSize
+ * @returns
+ */
+function calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, userHighLeverageMode, entryPrice) {
+    const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
+    const price = entryPrice !== null && entryPrice !== void 0 ? entryPrice : driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
+    const perpLiabilityValue = calculatePerpLiabilityValue(baseSize, price, (0, types_1.isVariant)(targetMarket.contractType, 'prediction'));
+    const marginRequired = new anchor_1.BN((0, __1.calculateMarketMarginRatio)(targetMarket, baseSize.abs(), 'Initial', userMaxMarginRatio, userHighLeverageMode))
+        .mul(perpLiabilityValue)
+        .div(numericConstants_1.MARGIN_PRECISION);
+    return marginRequired;
+}
+exports.calculateMarginUSDCRequiredForTrade = calculateMarginUSDCRequiredForTrade;
+/**
+ * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
+ *
+ * Returns collateral required in the precision of the target collateral market.
+ */
+function calculateCollateralDepositRequiredForTrade(driftClient, targetMarketIndex, baseSize, collateralIndex, userMaxMarginRatio, userHighLeverageMode, estEntryPrice) {
+    const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, userHighLeverageMode, estEntryPrice);
+    const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+    const collateralOracleData = driftClient.getOracleDataForSpotMarket(collateralIndex);
+    const scaledAssetWeight = (0, __1.calculateScaledInitialAssetWeight)(collateralMarket, collateralOracleData.price);
+    // Base amount required to deposit = (marginRequiredUsdc / priceOfAsset) / assetWeight .. (E.g. $100 required / $10000 price / 0.5 weight)
+    const baseAmountRequired = driftClient
+        .convertToSpotPrecision(collateralIndex, marginRequiredUsdc)
+        .mul(numericConstants_1.PRICE_PRECISION) // adjust for division by oracle price
+        .mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION) // adjust for division by scaled asset weight
+        .div(collateralOracleData.price)
+        .div(scaledAssetWeight)
+        .div(numericConstants_1.QUOTE_PRECISION); // adjust for marginRequiredUsdc value's QUOTE_PRECISION
+    // TODO : Round by step size?
+    return baseAmountRequired;
+}
+exports.calculateCollateralDepositRequiredForTrade = calculateCollateralDepositRequiredForTrade;
+function calculateCollateralValueOfDeposit(driftClient, collateralIndex, baseSize) {
+    const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+    const collateralOracleData = driftClient.getOracleDataForSpotMarket(collateralIndex);
+    const scaledAssetWeight = (0, __1.calculateScaledInitialAssetWeight)(collateralMarket, collateralOracleData.price);
+    // CollateralBaseValue = oracle price * collateral base amount (and shift to QUOTE_PRECISION)
+    const collateralBaseValue = collateralOracleData.price
+        .mul(baseSize)
+        .mul(numericConstants_1.QUOTE_PRECISION)
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(new anchor_1.BN(10).pow(new anchor_1.BN(collateralMarket.decimals)));
+    const depositCollateralValue = collateralBaseValue
+        .mul(scaledAssetWeight)
+        .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+    return depositCollateralValue;
+}
+exports.calculateCollateralValueOfDeposit = calculateCollateralValueOfDeposit;
+function calculateLiquidationPrice(freeCollateral, freeCollateralDelta, oraclePrice) {
+    const liqPriceDelta = freeCollateral
+        .mul(numericConstants_1.QUOTE_PRECISION)
+        .div(freeCollateralDelta);
+    const liqPrice = oraclePrice.sub(liqPriceDelta);
+    if (liqPrice.lt(numericConstants_1.ZERO)) {
+        return new anchor_1.BN(-1);
+    }
+    return liqPrice;
+}
+exports.calculateLiquidationPrice = calculateLiquidationPrice;

package/lib/browser/math/market.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { PerpMarketAccount, PositionDirection, MarginCategory, SpotMarketAccount } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import { DLOB } from '../dlob/DLOB';
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision PRICE_PRECISION
+ */
+export declare function calculateReservePrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision PRICE_PRECISION
+ */
+export declare function calculateBidPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return askPrice : Precision PRICE_PRECISION
+ */
+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, customMarginRatio?: number, userHighLeverageMode?: boolean): 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 calculateMarketMaxAvailableInsurance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;
+export declare function calculateNetUserPnl(perpMarket: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateNetUserPnlImbalance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount, oraclePriceData: OraclePriceData, applyFeePoolDiscount?: boolean): BN;
+export declare function calculateAvailablePerpLiquidity(market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number): {
+    bids: BN;
+    asks: BN;
+};

package/lib/browser/math/market.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAvailablePerpLiquidity = exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketMaxAvailableInsurance = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateOracleReserveSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
+const anchor_1 = require("@coral-xyz/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");
+const assert_1 = require("../assert/assert");
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision PRICE_PRECISION
+ */
+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.calculateReservePrice = calculateReservePrice;
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision PRICE_PRECISION
+ */
+function calculateBidPrice(market, oraclePriceData) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
+    return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateBidPrice = calculateBidPrice;
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return askPrice : Precision PRICE_PRECISION
+ */
+function calculateAskPrice(market, oraclePriceData) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
+    return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateAskPrice = calculateAskPrice;
+function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
+    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', direction));
+    const newAmm = Object.assign({}, market.amm);
+    const newMarket = Object.assign({}, market);
+    newMarket.amm = newAmm;
+    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+    return newMarket;
+}
+exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
+function calculateOracleReserveSpread(market, oraclePriceData) {
+    const reservePrice = calculateReservePrice(market, oraclePriceData);
+    return calculateOracleSpread(reservePrice, oraclePriceData);
+}
+exports.calculateOracleReserveSpread = calculateOracleReserveSpread;
+function calculateOracleSpread(price, oraclePriceData) {
+    return price.sub(oraclePriceData.price);
+}
+exports.calculateOracleSpread = calculateOracleSpread;
+function calculateMarketMarginRatio(market, size, marginCategory, customMarginRatio = 0, userHighLeverageMode = false) {
+    let marginRationInitial;
+    let marginRatioMaintenance;
+    if (userHighLeverageMode &&
+        market.highLeverageMarginRatioInitial > 0 &&
+        market.highLeverageMarginRatioMaintenance) {
+        marginRationInitial = market.highLeverageMarginRatioInitial;
+        marginRatioMaintenance = market.highLeverageMarginRatioMaintenance;
+    }
+    else {
+        marginRationInitial = market.marginRatioInitial;
+        marginRatioMaintenance = market.marginRatioMaintenance;
+    }
+    let marginRatio;
+    switch (marginCategory) {
+        case 'Initial': {
+            // use lowest leverage between max allowed and optional user custom max
+            marginRatio = Math.max((0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(marginRationInitial), numericConstants_1.MARGIN_PRECISION).toNumber(), customMarginRatio);
+            break;
+        }
+        case 'Maintenance': {
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(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 calculateMarketMaxAvailableInsurance(perpMarket, spotMarket) {
+    (0, assert_1.assert)(spotMarket.marketIndex == numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+    // todo: insuranceFundAllocation technically not guaranteed to be in Insurance Fund
+    const insuranceFundAllocation = perpMarket.insuranceClaim.quoteMaxInsurance.sub(perpMarket.insuranceClaim.quoteSettledInsurance);
+    const ammFeePool = (0, spotBalance_1.getTokenAmount)(perpMarket.amm.feePool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    return insuranceFundAllocation.add(ammFeePool);
+}
+exports.calculateMarketMaxAvailableInsurance = calculateMarketMaxAvailableInsurance;
+function calculateNetUserPnl(perpMarket, oraclePriceData) {
+    const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
+        .add(perpMarket.amm.baseAssetAmountWithUnsettledLp)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BASE_PRECISION)
+        .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    const netUserCostBasis = perpMarket.amm.quoteAssetAmount
+        .add(perpMarket.amm.quoteAssetAmountWithUnsettledLp)
+        .add(perpMarket.amm.netUnsettledFundingPnl);
+    const netUserPnl = netUserPositionValue.add(netUserCostBasis);
+    return netUserPnl;
+}
+exports.calculateNetUserPnl = calculateNetUserPnl;
+function calculateNetUserPnlImbalance(perpMarket, spotMarket, oraclePriceData, applyFeePoolDiscount = true) {
+    const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
+    const pnlPool = (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    let feePool = (0, spotBalance_1.getTokenAmount)(perpMarket.amm.feePool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    if (applyFeePoolDiscount) {
+        feePool = feePool.div(new anchor_1.BN(5));
+    }
+    const imbalance = netUserPnl.sub(pnlPool.add(feePool));
+    return imbalance;
+}
+exports.calculateNetUserPnlImbalance = calculateNetUserPnlImbalance;
+function calculateAvailablePerpLiquidity(market, oraclePriceData, dlob, slot) {
+    let [bids, asks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
+    asks = asks.abs();
+    for (const bid of dlob.getRestingLimitBids(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData)) {
+        bids = bids.add(bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled));
+    }
+    for (const ask of dlob.getRestingLimitAsks(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData)) {
+        asks = asks.add(ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled));
+    }
+    return {
+        bids: bids,
+        asks: asks,
+    };
+}
+exports.calculateAvailablePerpLiquidity = calculateAvailablePerpLiquidity;

package/lib/browser/math/oracles.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { AMM, OracleGuardRails } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import { BN, HistoricalOracleData, PerpMarketAccount } from '../index';
+export declare function oraclePriceBands(market: PerpMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];
+export declare function getMaxConfidenceIntervalMultiplier(market: PerpMarketAccount): BN;
+export declare function isOracleValid(market: PerpMarketAccount, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
+export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, now: BN): boolean;
+export declare function calculateLiveOracleTwap(histOracleData: HistoricalOracleData, oraclePriceData: OraclePriceData, now: BN, period: BN): BN;
+export declare function calculateLiveOracleStd(amm: AMM, oraclePriceData: OraclePriceData, now: BN): BN;
+export declare function getNewOracleConfPct(amm: AMM, oraclePriceData: OraclePriceData, reservePrice: BN, now: BN): BN;
+export declare function trimVaaSignatures(vaa: Buffer, n?: number): Buffer;

package/lib/browser/math/oracles.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimVaaSignatures = exports.getNewOracleConfPct = exports.calculateLiveOracleStd = exports.calculateLiveOracleTwap = exports.isOracleTooDivergent = exports.isOracleValid = exports.getMaxConfidenceIntervalMultiplier = exports.oraclePriceBands = void 0;
+const types_1 = require("../types");
+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.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 index_1.BN(1);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'b')) {
+        maxConfidenceIntervalMultiplier = new index_1.BN(1);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'c')) {
+        maxConfidenceIntervalMultiplier = new index_1.BN(2);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'speculative')) {
+        maxConfidenceIntervalMultiplier = new index_1.BN(10);
+    }
+    else {
+        maxConfidenceIntervalMultiplier = new index_1.BN(50);
+    }
+    return maxConfidenceIntervalMultiplier;
+}
+exports.getMaxConfidenceIntervalMultiplier = getMaxConfidenceIntervalMultiplier;
+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(index_1.BN.max(numericConstants_1.ONE, amm.historicalOracleData.lastOraclePriceTwap))
+        .gt(oracleGuardRails.validity.tooVolatileRatio) ||
+        amm.historicalOracleData.lastOraclePriceTwap
+            .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
+            .gt(oracleGuardRails.validity.tooVolatileRatio);
+    const maxConfidenceIntervalMultiplier = getMaxConfidenceIntervalMultiplier(market);
+    const isConfidenceTooLarge = index_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 index_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, now) {
+    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, numericConstants_1.FIVE_MINUTE.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 maxDivergence = index_1.BN.max(oracleGuardRails.priceDivergence.markOraclePercentDivergence, numericConstants_1.PERCENTAGE_PRECISION.div(new index_1.BN(10)));
+    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 = index_1.BN.max(numericConstants_1.ONE, now.sub(histOracleData.lastOraclePriceTwapTs));
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, period.sub(sinceLastUpdate));
+    const clampRange = oracleTwap.div(new index_1.BN(3));
+    const clampedOraclePrice = index_1.BN.min(oracleTwap.add(clampRange), index_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 = index_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+    const liveOracleTwap = calculateLiveOracleTwap(amm.historicalOracleData, oraclePriceData, now, amm.fundingPeriod);
+    const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).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 = index_1.BN.max(numericConstants_1.ZERO, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
+    let lowerBoundConfPct = amm.lastOracleConfPct;
+    if (sinceLastUpdate.gt(numericConstants_1.ZERO)) {
+        const lowerBoundConfDivisor = index_1.BN.max(new index_1.BN(21).sub(sinceLastUpdate), new index_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 = index_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;

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

@@ -0,0 +1,23 @@
+/// <reference types="bn.js" />
+import { User } from '../user';
+import { PerpMarketAccount, AMM, Order, PositionDirection } from '../types';
+import { BN } from '@coral-xyz/anchor';
+import { 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(order: Order, oraclePriceData: OraclePriceData, 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, oraclePriceData: OraclePriceData, slot: number, ts: number, minAuctionDuration: number): boolean;
+export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, amm: AMM, limitPrice: BN, oraclePriceData: OraclePriceData): 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;