@drift-labs/sdk 2.97.0-beta.3 → 2.97.0-beta.30

package/lib/node/math/auction.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveOracleAuctionParams = exports.getAuctionPriceForOracleOffsetAuction = exports.getAuctionPriceForFixedAuction = exports.getAuctionPrice = exports.isFallbackAvailableLiquiditySource = exports.isAuctionComplete = void 0;
+const types_1 = require("../types");
+const _1 = require("../.");
+function isAuctionComplete(order, slot) {
+    if (order.auctionDuration === 0) {
+        return true;
+    }
+    return new _1.BN(slot).sub(order.slot).gt(new _1.BN(order.auctionDuration));
+}
+exports.isAuctionComplete = isAuctionComplete;
+function isFallbackAvailableLiquiditySource(order, minAuctionDuration, slot) {
+    if (minAuctionDuration === 0) {
+        return true;
+    }
+    return new _1.BN(slot).sub(order.slot).gt(new _1.BN(minAuctionDuration));
+}
+exports.isFallbackAvailableLiquiditySource = isFallbackAvailableLiquiditySource;
+function getAuctionPrice(order, slot, oraclePrice) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, [
+        'market',
+        'triggerMarket',
+        'limit',
+        'triggerLimit',
+    ])) {
+        return getAuctionPriceForFixedAuction(order, slot);
+    }
+    else if ((0, types_1.isVariant)(order.orderType, 'oracle')) {
+        return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);
+    }
+    else {
+        throw Error(`Cant get auction price for order type ${(0, _1.getVariant)(order.orderType)}`);
+    }
+}
+exports.getAuctionPrice = getAuctionPrice;
+function getAuctionPriceForFixedAuction(order, slot) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    const deltaDenominator = new _1.BN(order.auctionDuration);
+    const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
+    if (deltaDenominator.eq(_1.ZERO)) {
+        return order.auctionEndPrice;
+    }
+    let priceDelta;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        priceDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let price;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        price = order.auctionStartPrice.add(priceDelta);
+    }
+    else {
+        price = order.auctionStartPrice.sub(priceDelta);
+    }
+    return price;
+}
+exports.getAuctionPriceForFixedAuction = getAuctionPriceForFixedAuction;
+function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    const deltaDenominator = new _1.BN(order.auctionDuration);
+    const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
+    if (deltaDenominator.eq(_1.ZERO)) {
+        return _1.BN.max(oraclePrice.add(order.auctionEndPrice), _1.ONE);
+    }
+    let priceOffsetDelta;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        priceOffsetDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceOffsetDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let priceOffset;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        priceOffset = order.auctionStartPrice.add(priceOffsetDelta);
+    }
+    else {
+        priceOffset = order.auctionStartPrice.sub(priceOffsetDelta);
+    }
+    return _1.BN.max(oraclePrice.add(priceOffset), _1.ONE);
+}
+exports.getAuctionPriceForOracleOffsetAuction = getAuctionPriceForOracleOffsetAuction;
+function deriveOracleAuctionParams({ direction, oraclePrice, auctionStartPrice, auctionEndPrice, limitPrice, auctionPriceCaps, }) {
+    let oraclePriceOffset;
+    if (limitPrice.eq(_1.ZERO) || oraclePrice.eq(_1.ZERO)) {
+        oraclePriceOffset = _1.ZERO;
+    }
+    else {
+        oraclePriceOffset = limitPrice.sub(oraclePrice);
+    }
+    if (oraclePriceOffset.eq(_1.ZERO)) {
+        oraclePriceOffset = (0, types_1.isVariant)(direction, 'long')
+            ? auctionEndPrice.sub(oraclePrice).add(_1.ONE)
+            : auctionEndPrice.sub(oraclePrice).sub(_1.ONE);
+    }
+    let oraclePriceOffsetNum;
+    try {
+        oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+    }
+    catch (e) {
+        oraclePriceOffsetNum = 0;
+    }
+    if (auctionPriceCaps) {
+        auctionStartPrice = _1.BN.min(_1.BN.max(auctionStartPrice, auctionPriceCaps.min), auctionPriceCaps.max);
+        auctionEndPrice = _1.BN.min(_1.BN.max(auctionEndPrice, auctionPriceCaps.min), auctionPriceCaps.max);
+    }
+    return {
+        auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+        auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+        oraclePriceOffset: oraclePriceOffsetNum,
+    };
+}
+exports.deriveOracleAuctionParams = deriveOracleAuctionParams;

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

@@ -0,0 +1,2 @@
+import { User } from '../user';
+export declare function isUserBankrupt(user: User): boolean;

package/lib/node/math/bankruptcy.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserBankrupt = void 0;
+const __1 = require("..");
+function isUserBankrupt(user) {
+    const userAccount = user.getUserAccount();
+    let hasLiability = false;
+    for (const position of userAccount.spotPositions) {
+        if (position.scaledBalance.gt(__1.ZERO)) {
+            if ((0, __1.isVariant)(position.balanceType, 'deposit')) {
+                return false;
+            }
+            if ((0, __1.isVariant)(position.balanceType, 'borrow')) {
+                hasLiability = true;
+            }
+        }
+    }
+    for (const position of userAccount.perpPositions) {
+        if (!position.baseAssetAmount.eq(__1.ZERO) ||
+            position.quoteAssetAmount.gt(__1.ZERO) ||
+            (0, __1.hasOpenOrders)(position) ||
+            position.lpShares.gt(__1.ZERO)) {
+            return false;
+        }
+        if (position.quoteAssetAmount.lt(__1.ZERO)) {
+            hasLiability = true;
+        }
+    }
+    return hasLiability;
+}
+exports.isUserBankrupt = isUserBankrupt;

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

@@ -0,0 +1,2 @@
+import { BN } from '../';
+export declare const convertToNumber: (bigNumber: BN, precision?: BN) => number;

package/lib/node/math/conversion.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToNumber = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const convertToNumber = (bigNumber, precision = numericConstants_1.PRICE_PRECISION) => {
+    if (!bigNumber)
+        return 0;
+    return (bigNumber.div(precision).toNumber() +
+        bigNumber.mod(precision).toNumber() / precision.toNumber());
+};
+exports.convertToNumber = convertToNumber;

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

@@ -0,0 +1,6 @@
+import { PerpMarketAccount, PerpOperation, SpotMarketAccount, SpotOperation, StateAccount, InsuranceFundOperation } from '../types';
+export declare function exchangePaused(state: StateAccount): boolean;
+export declare function fillPaused(state: StateAccount, market: PerpMarketAccount | SpotMarketAccount): boolean;
+export declare function ammPaused(state: StateAccount, market: PerpMarketAccount | SpotMarketAccount): boolean;
+export declare function isOperationPaused(pausedOperations: number, operation: PerpOperation | SpotOperation | InsuranceFundOperation): boolean;
+export declare function isAmmDrawdownPause(market: PerpMarketAccount): boolean;

package/lib/node/math/exchangeStatus.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAmmDrawdownPause = exports.isOperationPaused = exports.ammPaused = exports.fillPaused = exports.exchangePaused = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const types_1 = require("../types");
+const anchor_1 = require("@coral-xyz/anchor");
+function exchangePaused(state) {
+    return state.exchangeStatus !== types_1.ExchangeStatus.ACTIVE;
+}
+exports.exchangePaused = exchangePaused;
+function fillPaused(state, market) {
+    if ((state.exchangeStatus & types_1.ExchangeStatus.FILL_PAUSED) ===
+        types_1.ExchangeStatus.FILL_PAUSED) {
+        return true;
+    }
+    if (market.hasOwnProperty('amm')) {
+        return isOperationPaused(market.pausedOperations, types_1.PerpOperation.FILL);
+    }
+    else {
+        return isOperationPaused(market.pausedOperations, types_1.SpotOperation.FILL);
+    }
+}
+exports.fillPaused = fillPaused;
+function ammPaused(state, market) {
+    if ((state.exchangeStatus & types_1.ExchangeStatus.AMM_PAUSED) ===
+        types_1.ExchangeStatus.AMM_PAUSED) {
+        return true;
+    }
+    if (market.hasOwnProperty('amm')) {
+        const operationPaused = isOperationPaused(market.pausedOperations, types_1.PerpOperation.AMM_FILL);
+        if (operationPaused) {
+            return true;
+        }
+        if (isAmmDrawdownPause(market)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.ammPaused = ammPaused;
+function isOperationPaused(pausedOperations, operation) {
+    return (pausedOperations & operation) > 0;
+}
+exports.isOperationPaused = isOperationPaused;
+function isAmmDrawdownPause(market) {
+    let quoteDrawdownLimitBreached;
+    if ((0, types_1.isVariant)(market.contractTier, 'a') ||
+        (0, types_1.isVariant)(market.contractTier, 'b')) {
+        quoteDrawdownLimitBreached = market.amm.netRevenueSinceLastFunding.lte(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.muln(400));
+    }
+    else {
+        quoteDrawdownLimitBreached = market.amm.netRevenueSinceLastFunding.lte(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.muln(200));
+    }
+    if (quoteDrawdownLimitBreached) {
+        const percentDrawdown = market.amm.netRevenueSinceLastFunding
+            .mul(numericConstants_1.PERCENTAGE_PRECISION)
+            .div(anchor_1.BN.max(market.amm.totalFeeMinusDistributions, numericConstants_1.ONE));
+        let percentDrawdownLimitBreached;
+        if ((0, types_1.isVariant)(market.contractTier, 'a')) {
+            percentDrawdownLimitBreached = percentDrawdown.lte(numericConstants_1.PERCENTAGE_PRECISION.divn(50).neg());
+        }
+        else if ((0, types_1.isVariant)(market.contractTier, 'b')) {
+            percentDrawdownLimitBreached = percentDrawdown.lte(numericConstants_1.PERCENTAGE_PRECISION.divn(33).neg());
+        }
+        else if ((0, types_1.isVariant)(market.contractTier, 'c')) {
+            percentDrawdownLimitBreached = percentDrawdown.lte(numericConstants_1.PERCENTAGE_PRECISION.divn(25).neg());
+        }
+        else {
+            percentDrawdownLimitBreached = percentDrawdown.lte(numericConstants_1.PERCENTAGE_PRECISION.divn(20).neg());
+        }
+        if (percentDrawdownLimitBreached) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isAmmDrawdownPause = isAmmDrawdownPause;

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

@@ -0,0 +1,6 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { SpotMarketAccount, PerpMarketAccount } from '..';
+export declare function calculateInsuranceFuelBonus(spotMarket: SpotMarketAccount, tokenStakeAmount: BN, fuelBonusNumerator: BN): BN;
+export declare function calculateSpotFuelBonus(spotMarket: SpotMarketAccount, signedTokenValue: BN, fuelBonusNumerator: BN): BN;
+export declare function calculatePerpFuelBonus(perpMarket: PerpMarketAccount, baseAssetValue: BN, fuelBonusNumerator: BN): BN;

package/lib/node/math/fuel.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatePerpFuelBonus = exports.calculateSpotFuelBonus = exports.calculateInsuranceFuelBonus = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+function calculateInsuranceFuelBonus(spotMarket, tokenStakeAmount, fuelBonusNumerator) {
+    const result = tokenStakeAmount
+        .abs()
+        .mul(fuelBonusNumerator)
+        .mul(new anchor_1.BN(spotMarket.fuelBoostInsurance))
+        .div(numericConstants_1.FUEL_WINDOW)
+        .div(numericConstants_1.QUOTE_PRECISION.div(new anchor_1.BN(10)));
+    return result;
+}
+exports.calculateInsuranceFuelBonus = calculateInsuranceFuelBonus;
+function calculateSpotFuelBonus(spotMarket, signedTokenValue, fuelBonusNumerator) {
+    let result;
+    if (signedTokenValue.abs().lte(numericConstants_1.QUOTE_PRECISION)) {
+        result = numericConstants_1.ZERO;
+    }
+    else if (signedTokenValue.gt(new anchor_1.BN(0))) {
+        result = signedTokenValue
+            .abs()
+            .mul(fuelBonusNumerator)
+            .mul(new anchor_1.BN(spotMarket.fuelBoostDeposits))
+            .div(numericConstants_1.FUEL_WINDOW)
+            .div(numericConstants_1.QUOTE_PRECISION.div(new anchor_1.BN(10)));
+    }
+    else {
+        result = signedTokenValue
+            .abs()
+            .mul(fuelBonusNumerator)
+            .mul(new anchor_1.BN(spotMarket.fuelBoostBorrows))
+            .div(numericConstants_1.FUEL_WINDOW)
+            .div(numericConstants_1.QUOTE_PRECISION.div(new anchor_1.BN(10)));
+    }
+    return result;
+}
+exports.calculateSpotFuelBonus = calculateSpotFuelBonus;
+function calculatePerpFuelBonus(perpMarket, baseAssetValue, fuelBonusNumerator) {
+    let result;
+    if (baseAssetValue.abs().lte(numericConstants_1.QUOTE_PRECISION)) {
+        result = new anchor_1.BN(0);
+    }
+    else {
+        result = baseAssetValue
+            .abs()
+            .mul(fuelBonusNumerator)
+            .mul(new anchor_1.BN(perpMarket.fuelBoostPosition))
+            .div(numericConstants_1.FUEL_WINDOW)
+            .div(numericConstants_1.QUOTE_PRECISION.div(new anchor_1.BN(10)));
+    }
+    return result;
+}
+exports.calculatePerpFuelBonus = calculatePerpFuelBonus;

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

@@ -0,0 +1,34 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { PerpMarketAccount } from '../types';
+import { OraclePriceData } from '../oracles/types';
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export declare function calculateAllEstimatedFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, markPrice?: BN, now?: BN): Promise<[BN, BN, BN, BN, BN]>;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export declare function calculateLongShortFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, markPrice?: BN, now?: BN): Promise<[BN, BN]>;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export declare function calculateLongShortFundingRateAndLiveTwaps(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, markPrice?: BN, now?: BN): Promise<[BN, BN, BN, BN]>;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+export declare function calculateFundingPool(market: PerpMarketAccount): BN;

package/lib/node/math/funding.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFundingPool = exports.calculateLongShortFundingRateAndLiveTwaps = exports.calculateLongShortFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const types_1 = require("../types");
+const amm_1 = require("./amm");
+const oracles_1 = require("./oracles");
+const utils_1 = require("./utils");
+function calculateLiveMarkTwap(market, oraclePriceData, markPrice, now, period = new anchor_1.BN(3600)) {
+    now = now || new anchor_1.BN((Date.now() / 1000).toFixed(0));
+    const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
+    const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
+    const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
+    const markTwapTimeSinceLastUpdate = anchor_1.BN.max(period, anchor_1.BN.max(numericConstants_1.ZERO, period.sub(timeSinceLastMarkChange)));
+    if (!markPrice) {
+        const [bid, ask] = (0, amm_1.calculateBidAskPrice)(market.amm, oraclePriceData);
+        markPrice = bid.add(ask).div(new anchor_1.BN(2));
+    }
+    const markTwapWithMantissa = markTwapTimeSinceLastUpdate
+        .mul(lastMarkTwapWithMantissa)
+        .add(timeSinceLastMarkChange.mul(markPrice))
+        .div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
+    return markTwapWithMantissa;
+}
+function shrinkStaleTwaps(market, markTwapWithMantissa, oracleTwapWithMantissa, now) {
+    now = now || new anchor_1.BN((Date.now() / 1000).toFixed(0));
+    let newMarkTwap = markTwapWithMantissa;
+    let newOracleTwap = oracleTwapWithMantissa;
+    if (market.amm.lastMarkPriceTwapTs.gt(market.amm.historicalOracleData.lastOraclePriceTwapTs)) {
+        // shrink oracle based on invalid intervals
+        const oracleInvalidDuration = anchor_1.BN.max(numericConstants_1.ZERO, market.amm.lastMarkPriceTwapTs.sub(market.amm.historicalOracleData.lastOraclePriceTwapTs));
+        const timeSinceLastOracleTwapUpdate = now.sub(market.amm.historicalOracleData.lastOraclePriceTwapTs);
+        const oracleTwapTimeSinceLastUpdate = anchor_1.BN.max(numericConstants_1.ONE, anchor_1.BN.min(market.amm.fundingPeriod, anchor_1.BN.max(numericConstants_1.ONE, market.amm.fundingPeriod.sub(timeSinceLastOracleTwapUpdate))));
+        newOracleTwap = oracleTwapTimeSinceLastUpdate
+            .mul(oracleTwapWithMantissa)
+            .add(oracleInvalidDuration.mul(markTwapWithMantissa))
+            .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
+    }
+    else if (market.amm.lastMarkPriceTwapTs.lt(market.amm.historicalOracleData.lastOraclePriceTwapTs)) {
+        // shrink mark to oracle twap over tradless intervals
+        const tradelessDuration = anchor_1.BN.max(numericConstants_1.ZERO, market.amm.historicalOracleData.lastOraclePriceTwapTs.sub(market.amm.lastMarkPriceTwapTs));
+        const timeSinceLastMarkTwapUpdate = now.sub(market.amm.lastMarkPriceTwapTs);
+        const markTwapTimeSinceLastUpdate = anchor_1.BN.max(numericConstants_1.ONE, anchor_1.BN.min(market.amm.fundingPeriod, anchor_1.BN.max(numericConstants_1.ONE, market.amm.fundingPeriod.sub(timeSinceLastMarkTwapUpdate))));
+        newMarkTwap = markTwapTimeSinceLastUpdate
+            .mul(markTwapWithMantissa)
+            .add(tradelessDuration.mul(oracleTwapWithMantissa))
+            .div(markTwapTimeSinceLastUpdate.add(tradelessDuration));
+    }
+    return [newMarkTwap, newOracleTwap];
+}
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+async function calculateAllEstimatedFundingRate(market, oraclePriceData, markPrice, now) {
+    if ((0, types_1.isVariant)(market.status, 'uninitialized')) {
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
+    }
+    // todo: sufficiently differs from blockchain timestamp?
+    now = now || new anchor_1.BN((Date.now() / 1000).toFixed(0));
+    // calculate real-time mark and oracle twap
+    const liveMarkTwap = calculateLiveMarkTwap(market, oraclePriceData, markPrice, now, market.amm.fundingPeriod);
+    const liveOracleTwap = (0, oracles_1.calculateLiveOracleTwap)(market.amm.historicalOracleData, oraclePriceData, now, market.amm.fundingPeriod);
+    const [markTwap, oracleTwap] = shrinkStaleTwaps(market, liveMarkTwap, liveOracleTwap, now);
+    // if(!markTwap.eq(liveMarkTwap)){
+    // 	console.log('shrink mark:', liveMarkTwap.toString(), '->', markTwap.toString());
+    // }
+    // if(!oracleTwap.eq(liveOracleTwap)){
+    // 	console.log('shrink orac:', liveOracleTwap.toString(), '->', oracleTwap.toString());
+    // }
+    const twapSpread = markTwap.sub(oracleTwap);
+    const twapSpreadWithOffset = twapSpread.add(oracleTwap.abs().div(numericConstants_1.FUNDING_RATE_OFFSET_DENOMINATOR));
+    const maxSpread = getMaxPriceDivergenceForFundingRate(market, oracleTwap);
+    const clampedSpreadWithOffset = (0, utils_1.clampBN)(twapSpreadWithOffset, maxSpread.mul(new anchor_1.BN(-1)), maxSpread);
+    const twapSpreadPct = clampedSpreadWithOffset
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .mul(new anchor_1.BN(100))
+        .div(oracleTwap);
+    const secondsInHour = new anchor_1.BN(3600);
+    const hoursInDay = new anchor_1.BN(24);
+    const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
+    const lowerboundEst = twapSpreadPct
+        .mul(market.amm.fundingPeriod)
+        .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
+        .div(secondsInHour)
+        .div(secondsInHour)
+        .div(hoursInDay);
+    const interpEst = twapSpreadPct.div(hoursInDay);
+    const interpRateQuote = twapSpreadPct
+        .div(hoursInDay)
+        .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));
+    }
+    let cappedAltEst;
+    let largerSide;
+    let smallerSide;
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())) {
+        largerSide = market.amm.baseAssetAmountLong.abs();
+        smallerSide = market.amm.baseAssetAmountShort.abs();
+        if (twapSpread.gt(new anchor_1.BN(0))) {
+            return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
+        }
+    }
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())) {
+        largerSide = market.amm.baseAssetAmountShort.abs();
+        smallerSide = market.amm.baseAssetAmountLong.abs();
+        if (twapSpread.lt(new anchor_1.BN(0))) {
+            return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
+        }
+    }
+    else {
+        return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
+    }
+    if (largerSide.gt(numericConstants_1.ZERO)) {
+        // funding smaller flow
+        cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
+        const feePoolTopOff = feePoolSize
+            .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.PRICE_PRECISION)
+            .mul(new anchor_1.BN(100))
+            .div(oracleTwap);
+        if (cappedAltEst.abs().gte(interpEst.abs())) {
+            cappedAltEst = interpEst;
+        }
+    }
+    else {
+        cappedAltEst = interpEst;
+    }
+    return [markTwap, oracleTwap, lowerboundEst, cappedAltEst, interpEst];
+}
+exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+function getMaxPriceDivergenceForFundingRate(market, oracleTwap) {
+    if ((0, types_1.isVariant)(market.contractTier, 'a')) {
+        return oracleTwap.divn(33);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'b')) {
+        return oracleTwap.divn(33);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'c')) {
+        return oracleTwap.divn(20);
+    }
+    else {
+        return oracleTwap.divn(10);
+    }
+}
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+async function calculateLongShortFundingRate(market, oraclePriceData, markPrice, now) {
+    const [_1, _2, _, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(market, oraclePriceData, markPrice, now);
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
+        return [cappedAltEst, interpEst];
+    }
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)) {
+        return [interpEst, cappedAltEst];
+    }
+    else {
+        return [interpEst, interpEst];
+    }
+}
+exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+async function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, markPrice, now) {
+    const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(market, oraclePriceData, markPrice, now);
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())) {
+        return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
+    }
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())) {
+        return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
+    }
+    else {
+        return [markTwapLive, oracleTwapLive, interpEst, interpEst];
+    }
+}
+exports.calculateLongShortFundingRateAndLiveTwaps = calculateLongShortFundingRateAndLiveTwaps;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+function calculateFundingPool(market) {
+    // todo
+    const totalFeeLB = market.amm.totalExchangeFee.div(new anchor_1.BN(2));
+    const feePool = anchor_1.BN.max(numericConstants_1.ZERO, market.amm.totalFeeMinusDistributions
+        .sub(totalFeeLB)
+        .mul(new anchor_1.BN(1))
+        .div(new anchor_1.BN(3)));
+    return feePool;
+}
+exports.calculateFundingPool = calculateFundingPool;

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

@@ -0,0 +1,7 @@
+/// <reference types="bn.js" />
+import { BN, SpotMarketAccount } from '../index';
+export declare function nextRevenuePoolSettleApr(spotMarket: SpotMarketAccount, vaultBalance: BN, // vault token amount
+amount?: BN): number;
+export declare function stakeAmountToShares(amount: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;
+export declare function unstakeSharesToAmount(nShares: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;
+export declare function unstakeSharesToAmountWithOpenRequest(nShares: BN, withdrawRequestShares: BN, withdrawRequestAmount: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;

package/lib/node/math/insurance.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unstakeSharesToAmountWithOpenRequest = exports.unstakeSharesToAmount = exports.stakeAmountToShares = exports.nextRevenuePoolSettleApr = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+const spotBalance_1 = require("../math/spotBalance");
+function nextRevenuePoolSettleApr(spotMarket, vaultBalance, // vault token amount
+amount // delta token amount
+) {
+    const MAX_APR = new index_1.BN(10).mul(numericConstants_1.PERCENTAGE_PRECISION); // 1000% APR
+    // Conmputing the APR:
+    const revenuePoolBN = (0, spotBalance_1.getTokenAmount)(spotMarket.revenuePool.scaledBalance, spotMarket, index_1.SpotBalanceType.DEPOSIT);
+    const payoutRatio = 0.1;
+    const ratioForStakers = spotMarket.insuranceFund.totalFactor > 0 &&
+        spotMarket.insuranceFund.userFactor > 0 &&
+        spotMarket.insuranceFund.revenueSettlePeriod.gt(numericConstants_1.ZERO)
+        ? spotMarket.insuranceFund.userFactor /
+            spotMarket.insuranceFund.totalFactor
+        : 0;
+    // Settle periods from on-chain data:
+    const revSettlePeriod = spotMarket.insuranceFund.revenueSettlePeriod.toNumber() * 1000;
+    const settlesPerYear = 31536000000 / revSettlePeriod;
+    const projectedAnnualRev = revenuePoolBN
+        .muln(settlesPerYear)
+        .muln(payoutRatio);
+    const uncappedApr = vaultBalance.add(amount).eq(numericConstants_1.ZERO)
+        ? 0
+        : projectedAnnualRev.muln(1000).div(vaultBalance.add(amount)).toNumber() *
+            100 *
+            1000;
+    const cappedApr = Math.min(uncappedApr, MAX_APR.toNumber());
+    const nextApr = cappedApr * ratioForStakers;
+    return nextApr;
+}
+exports.nextRevenuePoolSettleApr = nextRevenuePoolSettleApr;
+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;
+function unstakeSharesToAmountWithOpenRequest(nShares, withdrawRequestShares, withdrawRequestAmount, totalIfShares, insuranceFundVaultBalance) {
+    let stakedAmount;
+    if (totalIfShares.gt(numericConstants_1.ZERO)) {
+        stakedAmount = index_1.BN.max(numericConstants_1.ZERO, nShares
+            .sub(withdrawRequestShares)
+            .mul(insuranceFundVaultBalance)
+            .div(totalIfShares));
+    }
+    else {
+        stakedAmount = numericConstants_1.ZERO;
+    }
+    const withdrawAmount = index_1.BN.min(withdrawRequestAmount, withdrawRequestShares.mul(insuranceFundVaultBalance).div(totalIfShares));
+    const amount = withdrawAmount.add(stakedAmount);
+    return amount;
+}
+exports.unstakeSharesToAmountWithOpenRequest = unstakeSharesToAmountWithOpenRequest;