@velocity-exchange/sdk 0.0.1

package/lib/browser/math/margin.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateUserMaxPerpOrderSize = exports.calculateLiquidationPrice = exports.calculateCollateralValueOfDeposit = exports.calculateCollateralDepositRequiredForTrade = exports.calculateMarginUSDCRequiredForTrade = exports.calculatePerpLiabilityValue = exports.calculateWorstCasePerpLiabilityValue = exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+/**
+ * Margin calculation helpers — TypeScript mirror of `programs/drift/src/math/margin.rs`.
+ * Computes initial/maintenance margin requirements, free collateral, and account health.
+ * Used by {@link User} for leverage queries and by keeper bots for liquidation eligibility checks.
+ */
+const utils_1 = require("./utils");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("../isomorphic/anchor");
+const market_1 = require("./market");
+const spotBalance_1 = require("./spotBalance");
+const oneShotUserAccountSubscriber_1 = require("../accounts/oneShotUserAccountSubscriber");
+const user_1 = require("../user");
+const types_1 = require("../types");
+const assert_1 = require("../assert/assert");
+function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, liabilityWeight, precision, isBounded = true) {
+    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
+    );
+    let maxLiabilityWeight;
+    if (isBounded) {
+        maxLiabilityWeight = anchor_1.BN.max(liabilityWeight, sizePremiumLiabilityWeight);
+    }
+    else {
+        maxLiabilityWeight = 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, includeOpenOrders = true) {
+    // return early if no open orders required
+    if (!includeOpenOrders) {
+        return {
+            worstCaseBaseAssetAmount: perpPosition.baseAssetAmount,
+            worstCaseLiabilityValue: calculatePerpLiabilityValue(perpPosition.baseAssetAmount, oraclePrice),
+        };
+    }
+    const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+    const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
+    const allBidsLiabilityValue = calculatePerpLiabilityValue(allBids, oraclePrice);
+    const allAsksLiabilityValue = calculatePerpLiabilityValue(allAsks, oraclePrice);
+    if (allAsksLiabilityValue.gte(allBidsLiabilityValue)) {
+        return {
+            worstCaseBaseAssetAmount: allAsks,
+            worstCaseLiabilityValue: allAsksLiabilityValue,
+        };
+    }
+    else {
+        return {
+            worstCaseBaseAssetAmount: allBids,
+            worstCaseLiabilityValue: allBidsLiabilityValue,
+        };
+    }
+}
+exports.calculateWorstCasePerpLiabilityValue = calculateWorstCasePerpLiabilityValue;
+function calculatePerpLiabilityValue(baseAssetAmount, price) {
+    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, entryPrice) {
+    const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
+    const price = entryPrice !== null && entryPrice !== void 0 ? entryPrice : driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
+    const perpLiabilityValue = calculatePerpLiabilityValue(baseSize, price);
+    const marginRequired = new anchor_1.BN((0, market_1.calculateMarketMarginRatio)(targetMarket, baseSize.abs(), 'Initial', userMaxMarginRatio))
+        .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, estEntryPrice) {
+    const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, estEntryPrice);
+    const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+    const collateralOracleData = driftClient.getOracleDataForSpotMarket(collateralIndex);
+    const scaledAssetWeight = (0, spotBalance_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, spotBalance_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;
+function calculateUserMaxPerpOrderSize(driftClient, userAccountKey, userAccount, targetMarketIndex, tradeSide) {
+    const userAccountSubscriber = new oneShotUserAccountSubscriber_1.OneShotUserAccountSubscriber(driftClient.program, userAccountKey, userAccount);
+    const user = new user_1.User({
+        driftClient,
+        userAccountPublicKey: userAccountKey,
+        accountSubscription: {
+            type: 'custom',
+            userAccountSubscriber: userAccountSubscriber,
+        },
+    });
+    user.isSubscribed = true;
+    return user.getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide);
+}
+exports.calculateUserMaxPerpOrderSize = calculateUserMaxPerpOrderSize;

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

@@ -0,0 +1,50 @@
+/// <reference types="bn.js" />
+import { BN } from '../isomorphic/anchor';
+import { PerpMarketAccount, PositionDirection, MarginCategory, SpotMarketAccount } from '../types';
+import { MMOraclePriceData, 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, mmOraclePriceData: MMOraclePriceData): BN;
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision PRICE_PRECISION
+ */
+export declare function calculateBidPrice(market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, latestSlot?: BN): BN;
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return askPrice : Precision PRICE_PRECISION
+ */
+export declare function calculateAskPrice(market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, latestSlot?: BN): BN;
+export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: PerpMarketAccount): PerpMarketAccount;
+export declare function calculateOracleReserveSpread(market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData): BN;
+export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarketMarginRatio(market: PerpMarketAccount, size: BN, marginCategory: MarginCategory, customMarginRatio?: number): number;
+export declare function calculateUnrealizedAssetWeight(market: PerpMarketAccount, quoteSpotMarket: SpotMarketAccount, unrealizedPnl: BN, marginCategory: MarginCategory, oraclePriceData: Pick<OraclePriceData, 'price'>): 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: Pick<OraclePriceData, 'price'>): BN;
+export declare function calculateNetUserPnlImbalance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount, oraclePriceData: Pick<OraclePriceData, 'price'>, applyFeePoolDiscount?: boolean): BN;
+export declare function calculateAvailablePerpLiquidity(market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, dlob: DLOB, slot: number): {
+    bids: BN;
+    asks: BN;
+};
+export declare function calculatePerpMarketBaseLiquidatorFee(market: PerpMarketAccount): number;
+/**
+ * Calculates trigger price for a perp market based on oracle price and current time
+ * Implements the same logic as the Rust get_trigger_price function
+ *
+ * @param market - The perp market account
+ * @param oraclePrice - Current oracle price (precision: PRICE_PRECISION)
+ * @param now - Current timestamp in seconds
+ * @returns trigger price (precision: PRICE_PRECISION)
+ */
+export declare function getTriggerPrice(market: PerpMarketAccount, oraclePrice: BN, now: BN, useMedianPrice: boolean): BN;

package/lib/browser/math/market.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTriggerPrice = exports.calculatePerpMarketBaseLiquidatorFee = 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("../isomorphic/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, mmOraclePriceData) {
+    const newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, mmOraclePriceData);
+    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, mmOraclePriceData, latestSlot) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, mmOraclePriceData, latestSlot);
+    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, mmOraclePriceData, latestSlot) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, mmOraclePriceData, latestSlot);
+    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, mmOraclePriceData) {
+    const reservePrice = calculateReservePrice(market, mmOraclePriceData);
+    return calculateOracleSpread(reservePrice, mmOraclePriceData);
+}
+exports.calculateOracleReserveSpread = calculateOracleReserveSpread;
+function calculateOracleSpread(price, oraclePriceData) {
+    return price.sub(oraclePriceData.price);
+}
+exports.calculateOracleSpread = calculateOracleSpread;
+function calculateMarketMarginRatio(market, size, marginCategory, customMarginRatio = 0) {
+    if (market.status === 'Settlement')
+        return 0;
+    let defaultMarginRatio;
+    switch (marginCategory) {
+        case 'Initial':
+            defaultMarginRatio = market.marginRatioInitial;
+            break;
+        case 'Maintenance':
+            defaultMarginRatio = market.marginRatioMaintenance;
+            break;
+        default:
+            throw new Error('Invalid margin category');
+    }
+    let marginRatio;
+    const sizeAdjMarginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(defaultMarginRatio), numericConstants_1.MARGIN_PRECISION, true).toNumber();
+    marginRatio = Math.max(defaultMarginRatio, sizeAdjMarginRatio);
+    if (marginCategory === 'Initial') {
+        marginRatio = Math.max(marginRatio, customMarginRatio);
+    }
+    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
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BASE_PRECISION)
+        .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    const netUserCostBasis = perpMarket.amm.quoteAssetAmount.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, mmOraclePriceData, 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, mmOraclePriceData)) {
+        bids = bids.add(bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled));
+    }
+    for (const ask of dlob.getRestingLimitAsks(market.marketIndex, slot, types_1.MarketType.PERP, mmOraclePriceData)) {
+        asks = asks.add(ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled));
+    }
+    return {
+        bids: bids,
+        asks: asks,
+    };
+}
+exports.calculateAvailablePerpLiquidity = calculateAvailablePerpLiquidity;
+function calculatePerpMarketBaseLiquidatorFee(market) {
+    return market.liquidatorFee;
+}
+exports.calculatePerpMarketBaseLiquidatorFee = calculatePerpMarketBaseLiquidatorFee;
+/**
+ * Calculates trigger price for a perp market based on oracle price and current time
+ * Implements the same logic as the Rust get_trigger_price function
+ *
+ * @param market - The perp market account
+ * @param oraclePrice - Current oracle price (precision: PRICE_PRECISION)
+ * @param now - Current timestamp in seconds
+ * @returns trigger price (precision: PRICE_PRECISION)
+ */
+function getTriggerPrice(market, oraclePrice, now, useMedianPrice) {
+    if (!useMedianPrice) {
+        return oraclePrice.abs();
+    }
+    const lastFillPrice = market.lastFillPrice;
+    // Calculate 5-minute basis
+    const markPrice5minTwap = market.amm.lastMarkPriceTwap5Min;
+    const lastOraclePriceTwap5min = market.amm.historicalOracleData.lastOraclePriceTwap5Min;
+    const basis5min = markPrice5minTwap.sub(lastOraclePriceTwap5min);
+    const oraclePlusBasis5min = oraclePrice.add(basis5min);
+    // Calculate funding basis
+    const lastFundingBasis = getLastFundingBasis(market, oraclePrice, now);
+    const oraclePlusFundingBasis = oraclePrice.add(lastFundingBasis);
+    const prices = [
+        lastFillPrice.gt(numericConstants_1.ZERO) ? lastFillPrice : oraclePrice,
+        oraclePlusFundingBasis,
+        oraclePlusBasis5min,
+    ].sort((a, b) => a.cmp(b));
+    const medianPrice = prices[1];
+    return clampTriggerPrice(market, oraclePrice.abs(), medianPrice);
+}
+exports.getTriggerPrice = getTriggerPrice;
+/**
+ * Calculates the last funding basis for trigger price calculation
+ * Implements the same logic as the Rust get_last_funding_basis function
+ */
+function getLastFundingBasis(market, oraclePrice, now) {
+    if (market.amm.lastFundingOracleTwap.gt(numericConstants_1.ZERO)) {
+        const lastFundingRate = market.amm.lastFundingRate
+            .mul(numericConstants_1.PRICE_PRECISION)
+            .div(market.amm.lastFundingOracleTwap)
+            .muln(24);
+        const lastFundingRatePreAdj = lastFundingRate.sub(numericConstants_1.FUNDING_RATE_PRECISION.div(new anchor_1.BN(3333)) // FUNDING_RATE_OFFSET_PERCENTAGE
+        );
+        const timeLeftUntilFundingUpdate = anchor_1.BN.min(anchor_1.BN.max(now.sub(market.amm.lastFundingRateTs), numericConstants_1.ZERO), market.amm.fundingPeriod);
+        const lastFundingBasis = oraclePrice
+            .mul(lastFundingRatePreAdj)
+            .div(numericConstants_1.PERCENTAGE_PRECISION)
+            .mul(market.amm.fundingPeriod.sub(timeLeftUntilFundingUpdate))
+            .div(market.amm.fundingPeriod)
+            .div(new anchor_1.BN(1000)); // FUNDING_RATE_BUFFER
+        return lastFundingBasis;
+    }
+    else {
+        return numericConstants_1.ZERO;
+    }
+}
+/**
+ * Clamps trigger price based on contract tier
+ * Implements the same logic as the Rust clamp_trigger_price function
+ */
+function clampTriggerPrice(market, oraclePrice, medianPrice) {
+    let maxBpsDiff;
+    const tier = market.contractTier;
+    if ((0, types_1.isVariant)(tier, 'a') || (0, types_1.isVariant)(tier, 'b')) {
+        maxBpsDiff = new anchor_1.BN(500); // 20 BPS
+    }
+    else if ((0, types_1.isVariant)(tier, 'c')) {
+        maxBpsDiff = new anchor_1.BN(100); // 100 BPS
+    }
+    else {
+        maxBpsDiff = new anchor_1.BN(40); // 250 BPS
+    }
+    const maxOracleDiff = oraclePrice.div(maxBpsDiff);
+    return anchor_1.BN.min(anchor_1.BN.max(medianPrice, oraclePrice.sub(maxOracleDiff)), oraclePrice.add(maxOracleDiff));
+}

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

@@ -0,0 +1,19 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { AMM, HistoricalOracleData, OracleGuardRails, OracleSource, OracleValidity, PerpMarketAccount } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import { BN } from '../isomorphic/anchor';
+export declare function oraclePriceBands(market: PerpMarketAccount, oraclePriceData: Pick<OraclePriceData, 'price'>): [BN, BN];
+export declare function getMaxConfidenceIntervalMultiplier(market: PerpMarketAccount): BN;
+export declare function getOracleValidity(market: PerpMarketAccount, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: BN, oracleStalenessBuffer?: BN): OracleValidity;
+export declare function isOracleValid(market: PerpMarketAccount, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
+export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails): 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;
+export declare function getMultipleBetweenOracleSources(firstOracleSource: OracleSource, secondOracleSource: OracleSource): {
+    numerator: BN;
+    denominator: BN;
+};