@drift-labs/sdk 0.2.0-master.12 → 0.2.0-master.15

package/src/math/amm.js

@@ -1,369 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
-const types_1 = require("../types");
-const assert_1 = require("../assert/assert");
-const __1 = require("..");
-const repeg_1 = require("./repeg");
-function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
-    return targetPrice
-        .mul(baseAssetReserve)
-        .div(quoteAssetReserve)
-        .add(numericConstants_1.PRICE_DIV_PEG.div(new anchor_1.BN(2)))
-        .div(numericConstants_1.PRICE_DIV_PEG);
-}
-exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
-function calculateOptimalPegAndBudget(amm, oraclePriceData) {
-    const markPriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
-    const targetPrice = oraclePriceData.price;
-    const newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
-    const prePegCost = repeg_1.calculateRepegCost(amm, newPeg);
-    const totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
-    const budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
-    if (budget.lt(prePegCost)) {
-        const maxPriceSpread = new anchor_1.BN(amm.maxSpread)
-            .mul(targetPrice)
-            .div(numericConstants_1.BID_ASK_SPREAD_PRECISION);
-        let newTargetPrice;
-        let newOptimalPeg;
-        let newBudget;
-        const targetPriceGap = markPriceBefore.sub(targetPrice);
-        if (targetPriceGap.abs().gt(maxPriceSpread)) {
-            const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
-            if (targetPriceGap.lt(new anchor_1.BN(0))) {
-                newTargetPrice = markPriceBefore.add(markAdj);
-            }
-            else {
-                newTargetPrice = markPriceBefore.sub(markAdj);
-            }
-            newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
-            newBudget = repeg_1.calculateRepegCost(amm, newOptimalPeg);
-            return [newTargetPrice, newOptimalPeg, newBudget, false];
-        }
-    }
-    return [targetPrice, newPeg, budget, true];
-}
-exports.calculateOptimalPegAndBudget = calculateOptimalPegAndBudget;
-function calculateNewAmm(amm, oraclePriceData) {
-    let pKNumer = new anchor_1.BN(1);
-    let pKDenom = new anchor_1.BN(1);
-    const [targetPrice, _newPeg, budget, checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
-    let prePegCost = repeg_1.calculateRepegCost(amm, _newPeg);
-    let newPeg = _newPeg;
-    if (prePegCost.gt(budget) && checkLowerBound) {
-        [pKNumer, pKDenom] = [new anchor_1.BN(999), new anchor_1.BN(1000)];
-        const deficitMadeup = repeg_1.calculateAdjustKCost(amm, pKNumer, pKDenom);
-        assert_1.assert(deficitMadeup.lte(new anchor_1.BN(0)));
-        prePegCost = budget.add(deficitMadeup.abs());
-        const newAmm = Object.assign({}, amm);
-        newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
-        newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
-        const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
-        newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-        const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
-            ? types_1.PositionDirection.SHORT
-            : types_1.PositionDirection.LONG;
-        const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
-        newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
-        newPeg = repeg_1.calculateBudgetedPeg(newAmm, prePegCost, targetPrice);
-        prePegCost = repeg_1.calculateRepegCost(newAmm, newPeg);
-    }
-    return [prePegCost, pKNumer, pKDenom, newPeg];
-}
-exports.calculateNewAmm = calculateNewAmm;
-function calculateUpdatedAMM(amm, oraclePriceData) {
-    if (amm.curveUpdateIntensity == 0) {
-        return amm;
-    }
-    const newAmm = Object.assign({}, amm);
-    const [prepegCost, pKNumer, pKDenom, newPeg] = calculateNewAmm(amm, oraclePriceData);
-    newAmm.baseAssetReserve = newAmm.baseAssetReserve.mul(pKNumer).div(pKDenom);
-    newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
-    const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
-    newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-    newAmm.pegMultiplier = newPeg;
-    const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.SHORT
-        : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
-    newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
-    newAmm.totalFeeMinusDistributions =
-        newAmm.totalFeeMinusDistributions.sub(prepegCost);
-    return newAmm;
-}
-exports.calculateUpdatedAMM = calculateUpdatedAMM;
-function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
-    const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-    const dirReserves = calculateSpreadReserves(newAmm, direction, oraclePriceData);
-    const result = {
-        baseAssetReserve: dirReserves.baseAssetReserve,
-        quoteAssetReserve: dirReserves.quoteAssetReserve,
-        sqrtK: newAmm.sqrtK,
-        newPeg: newAmm.pegMultiplier,
-    };
-    return result;
-}
-exports.calculateUpdatedAMMSpreadReserves = calculateUpdatedAMMSpreadReserves;
-function calculateBidAskPrice(amm, oraclePriceData, withUpdate = true) {
-    let newAmm;
-    if (withUpdate) {
-        newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-    }
-    else {
-        newAmm = amm;
-    }
-    const askReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.LONG, oraclePriceData);
-    const bidReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.SHORT, oraclePriceData);
-    const askPrice = calculatePrice(askReserves.baseAssetReserve, askReserves.quoteAssetReserve, newAmm.pegMultiplier);
-    const bidPrice = calculatePrice(bidReserves.baseAssetReserve, bidReserves.quoteAssetReserve, newAmm.pegMultiplier);
-    return [bidPrice, askPrice];
-}
-exports.calculateBidAskPrice = calculateBidAskPrice;
-/**
- * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
- *
- * @param baseAssetReserves
- * @param quoteAssetReserves
- * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
- */
-function calculatePrice(baseAssetReserves, quoteAssetReserves, pegMultiplier) {
-    if (baseAssetReserves.abs().lte(numericConstants_1.ZERO)) {
-        return new anchor_1.BN(0);
-    }
-    return quoteAssetReserves
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(pegMultiplier)
-        .div(numericConstants_1.PEG_PRECISION)
-        .div(baseAssetReserves);
-}
-exports.calculatePrice = calculatePrice;
-/**
- * Calculates what the amm reserves would be after swapping a quote or base asset amount.
- *
- * @param amm
- * @param inputAssetType
- * @param swapAmount
- * @param swapDirection
- * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
- */
-function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDirection) {
-    assert_1.assert(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
-    let newQuoteAssetReserve;
-    let newBaseAssetReserve;
-    if (inputAssetType === 'quote') {
-        swapAmount = swapAmount
-            .mul(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
-            .div(amm.pegMultiplier);
-        [newQuoteAssetReserve, newBaseAssetReserve] = calculateSwapOutput(amm.quoteAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK));
-    }
-    else {
-        [newBaseAssetReserve, newQuoteAssetReserve] = calculateSwapOutput(amm.baseAssetReserve, swapAmount, swapDirection, amm.sqrtK.mul(amm.sqrtK));
-    }
-    return [newQuoteAssetReserve, newBaseAssetReserve];
-}
-exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
-function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
-    // inventory skew
-    const netBaseAssetValue = quoteAssetReserve
-        .sub(terminalQuoteAssetReserve)
-        .mul(pegMultiplier)
-        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    const localBaseAssetValue = netBaseAssetAmount
-        .mul(markPrice)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-    const effectiveLeverage = localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
-        (Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
-        1 / numericConstants_1.QUOTE_PRECISION.toNumber();
-    return effectiveLeverage;
-}
-exports.calculateEffectiveLeverage = calculateEffectiveLeverage;
-function calculateMaxSpread(marginRatioInitial) {
-    const maxTargetSpread = new anchor_1.BN(marginRatioInitial)
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(numericConstants_1.MARGIN_PRECISION))
-        .toNumber();
-    return maxTargetSpread;
-}
-exports.calculateMaxSpread = calculateMaxSpread;
-function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
-    let longSpread = baseSpread / 2;
-    let shortSpread = baseSpread / 2;
-    if (lastOracleMarkSpreadPct.gt(numericConstants_1.ZERO)) {
-        shortSpread = Math.max(shortSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
-    }
-    else if (lastOracleMarkSpreadPct.lt(numericConstants_1.ZERO)) {
-        longSpread = Math.max(longSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
-    }
-    const maxTargetSpread = maxSpread;
-    const MAX_INVENTORY_SKEW = 5;
-    const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions);
-    if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
-        const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
-        if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
-            longSpread *= spreadScale;
-        }
-        else {
-            shortSpread *= spreadScale;
-        }
-    }
-    else {
-        longSpread *= MAX_INVENTORY_SKEW;
-        shortSpread *= MAX_INVENTORY_SKEW;
-    }
-    const totalSpread = longSpread + shortSpread;
-    if (totalSpread > maxTargetSpread) {
-        if (longSpread > shortSpread) {
-            longSpread = Math.min(longSpread, maxTargetSpread);
-            shortSpread = maxTargetSpread - longSpread;
-        }
-        else {
-            shortSpread = Math.min(shortSpread, maxTargetSpread);
-            longSpread = maxTargetSpread - shortSpread;
-        }
-    }
-    return [longSpread, shortSpread];
-}
-exports.calculateSpreadBN = calculateSpreadBN;
-function calculateSpread(amm, direction, oraclePriceData) {
-    if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-        return amm.baseSpread / 2;
-    }
-    const markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
-    const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
-    const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
-    const targetMarkSpreadPct = markPrice
-        .sub(targetPrice)
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
-        .div(markPrice);
-    const confIntervalPct = confInterval
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
-        .div(markPrice);
-    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions);
-    let spread;
-    if (types_1.isVariant(direction, 'long')) {
-        spread = longSpread;
-    }
-    else {
-        spread = shortSpread;
-    }
-    return spread;
-}
-exports.calculateSpread = calculateSpread;
-function calculateSpreadReserves(amm, direction, oraclePriceData) {
-    const spread = calculateSpread(amm, direction, oraclePriceData);
-    if (spread === 0) {
-        return {
-            baseAssetReserve: amm.baseAssetReserve,
-            quoteAssetReserve: amm.quoteAssetReserve,
-        };
-    }
-    const quoteAsserReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
-    let quoteAssetReserve;
-    if (types_1.isVariant(direction, 'long')) {
-        quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
-    }
-    else {
-        quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
-    }
-    const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
-    return {
-        baseAssetReserve,
-        quoteAssetReserve,
-    };
-}
-exports.calculateSpreadReserves = calculateSpreadReserves;
-/**
- * Helper function calculating constant product curve output. Agnostic to whether input asset is quote or base
- *
- * @param inputAssetReserve
- * @param swapAmount
- * @param swapDirection
- * @param invariant
- * @returns newInputAssetReserve and newOutputAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
- */
-function calculateSwapOutput(inputAssetReserve, swapAmount, swapDirection, invariant) {
-    let newInputAssetReserve;
-    if (swapDirection === types_1.SwapDirection.ADD) {
-        newInputAssetReserve = inputAssetReserve.add(swapAmount);
-    }
-    else {
-        newInputAssetReserve = inputAssetReserve.sub(swapAmount);
-    }
-    const newOutputAssetReserve = invariant.div(newInputAssetReserve);
-    return [newInputAssetReserve, newOutputAssetReserve];
-}
-exports.calculateSwapOutput = calculateSwapOutput;
-/**
- * Translate long/shorting quote/base asset into amm operation
- *
- * @param inputAssetType
- * @param positionDirection
- */
-function getSwapDirection(inputAssetType, positionDirection) {
-    if (types_1.isVariant(positionDirection, 'long') && inputAssetType === 'base') {
-        return types_1.SwapDirection.REMOVE;
-    }
-    if (types_1.isVariant(positionDirection, 'short') && inputAssetType === 'quote') {
-        return types_1.SwapDirection.REMOVE;
-    }
-    return types_1.SwapDirection.ADD;
-}
-exports.getSwapDirection = getSwapDirection;
-/**
- * Helper function calculating terminal price of amm
- *
- * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
- */
-function calculateTerminalPrice(market) {
-    const directionToClose = market.amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.SHORT
-        : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
-    const terminalPrice = newQuoteAssetReserve
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(market.amm.pegMultiplier)
-        .div(numericConstants_1.PEG_PRECISION)
-        .div(newBaseAssetReserve);
-    return terminalPrice;
-}
-exports.calculateTerminalPrice = calculateTerminalPrice;
-function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oraclePriceData) {
-    const invariant = amm.sqrtK.mul(amm.sqrtK);
-    const newBaseAssetReserveSquared = invariant
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(amm.pegMultiplier)
-        .div(limit_price)
-        .div(numericConstants_1.PEG_PRECISION);
-    const newBaseAssetReserve = __1.squareRootBN(newBaseAssetReserveSquared);
-    const baseAssetReserveBefore = calculateSpreadReserves(amm, direction, oraclePriceData).baseAssetReserve;
-    if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
-        return [
-            newBaseAssetReserve.sub(baseAssetReserveBefore),
-            types_1.PositionDirection.SHORT,
-        ];
-    }
-    else if (newBaseAssetReserve.lt(baseAssetReserveBefore)) {
-        return [
-            baseAssetReserveBefore.sub(newBaseAssetReserve),
-            types_1.PositionDirection.LONG,
-        ];
-    }
-    else {
-        console.log('tradeSize Too Small');
-        return [new anchor_1.BN(0), types_1.PositionDirection.LONG];
-    }
-}
-exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
-function calculateQuoteAssetAmountSwapped(quoteAssetReserves, pegMultiplier, swapDirection) {
-    let quoteAssetAmount = quoteAssetReserves
-        .mul(pegMultiplier)
-        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    if (types_1.isVariant(swapDirection, 'remove')) {
-        quoteAssetAmount = quoteAssetAmount.add(numericConstants_1.ONE);
-    }
-    return quoteAssetAmount;
-}
-exports.calculateQuoteAssetAmountSwapped = calculateQuoteAssetAmountSwapped;

package/src/math/auction.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAuctionPrice = 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 getAuctionPrice(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 (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 (types_1.isVariant(order.direction, 'long')) {
-        price = order.auctionStartPrice.add(priceDelta);
-    }
-    else {
-        price = order.auctionStartPrice.sub(priceDelta);
-    }
-    return price;
-}
-exports.getAuctionPrice = getAuctionPrice;

package/src/math/conversion.js

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

package/src/math/funding.js

@@ -1,248 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateFundingPool = exports.calculateLongShortFundingRateAndLiveTwaps = exports.calculateLongShortFundingRate = exports.calculateEstimatedFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
-const market_1 = require("./market");
-/**
- *
- * @param market
- * @param oraclePriceData
- * @param periodAdjustment
- * @returns Estimated funding rate. : Precision //TODO-PRECISION
- */
-function calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // periodAdjustment
-        // 	1: hourly
-        //  24: daily
-        //  24 * 365.25: annualized
-        const secondsInHour = new anchor_1.BN(3600);
-        const hoursInDay = new anchor_1.BN(24);
-        const ONE = new anchor_1.BN(1);
-        if (!market.initialized) {
-            return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
-        }
-        const payFreq = new anchor_1.BN(market.amm.fundingPeriod);
-        // todo: sufficiently differs from blockchain timestamp?
-        const now = new anchor_1.BN((Date.now() / 1000).toFixed(0));
-        const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
-        // calculate real-time mark twap
-        const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
-        const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
-        const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
-        const markTwapTimeSinceLastUpdate = anchor_1.BN.max(secondsInHour, anchor_1.BN.max(numericConstants_1.ZERO, secondsInHour.sub(timeSinceLastMarkChange)));
-        const baseAssetPriceWithMantissa = market_1.calculateMarkPrice(market, oraclePriceData);
-        const markTwapWithMantissa = markTwapTimeSinceLastUpdate
-            .mul(lastMarkTwapWithMantissa)
-            .add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))
-            .div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
-        // calculate real-time (predicted) oracle twap
-        // note: oracle twap depends on `when the chord is struck` (market is trade)
-        const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
-        const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
-        const oracleInvalidDuration = anchor_1.BN.max(numericConstants_1.ZERO, lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs));
-        const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
-        const oracleTwapTimeSinceLastUpdate = anchor_1.BN.max(ONE, anchor_1.BN.min(secondsInHour, anchor_1.BN.max(ONE, secondsInHour.sub(timeSinceLastOracleTwapUpdate))));
-        let oracleTwapWithMantissa = lastOracleTwapWithMantissa;
-        // if passing live oracle data, improve predicted calc estimate
-        if (oraclePriceData) {
-            const oraclePrice = oraclePriceData.price;
-            const oracleLiveVsTwap = oraclePrice
-                .sub(lastOracleTwapWithMantissa)
-                .abs()
-                .mul(numericConstants_1.MARK_PRICE_PRECISION)
-                .mul(new anchor_1.BN(100))
-                .div(lastOracleTwapWithMantissa);
-            // verify pyth live input is within 10% of last twap for live update
-            if (oracleLiveVsTwap.lte(numericConstants_1.MARK_PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
-                oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
-                    .mul(lastOracleTwapWithMantissa)
-                    .add(timeSinceLastMarkChange.mul(oraclePrice))
-                    .div(timeSinceLastMarkChange.add(oracleTwapTimeSinceLastUpdate));
-            }
-        }
-        const shrunkLastOracleTwapwithMantissa = oracleTwapTimeSinceLastUpdate
-            .mul(lastOracleTwapWithMantissa)
-            .add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
-            .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
-        const twapSpread = lastMarkTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
-        const twapSpreadPct = twapSpread
-            .mul(numericConstants_1.MARK_PRICE_PRECISION)
-            .mul(new anchor_1.BN(100))
-            .div(shrunkLastOracleTwapwithMantissa);
-        const lowerboundEst = twapSpreadPct
-            .mul(payFreq)
-            .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
-            .mul(periodAdjustment)
-            .div(secondsInHour)
-            .div(secondsInHour)
-            .div(hoursInDay);
-        const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
-        const interpRateQuote = twapSpreadPct
-            .mul(periodAdjustment)
-            .div(hoursInDay)
-            .div(numericConstants_1.MARK_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.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-            largerSide = market.baseAssetAmountLong.abs();
-            smallerSide = market.baseAssetAmountShort.abs();
-            if (twapSpread.gt(new anchor_1.BN(0))) {
-                return [
-                    markTwapWithMantissa,
-                    oracleTwapWithMantissa,
-                    lowerboundEst,
-                    interpEst,
-                    interpEst,
-                ];
-            }
-        }
-        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
-            largerSide = market.baseAssetAmountShort.abs();
-            smallerSide = market.baseAssetAmountLong.abs();
-            if (twapSpread.lt(new anchor_1.BN(0))) {
-                return [
-                    markTwapWithMantissa,
-                    oracleTwapWithMantissa,
-                    lowerboundEst,
-                    interpEst,
-                    interpEst,
-                ];
-            }
-        }
-        else {
-            return [
-                markTwapWithMantissa,
-                oracleTwapWithMantissa,
-                lowerboundEst,
-                interpEst,
-                interpEst,
-            ];
-        }
-        if (largerSide.gt(numericConstants_1.ZERO)) {
-            // funding smaller flow
-            cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
-            const feePoolTopOff = feePoolSize
-                .mul(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
-                .mul(numericConstants_1.AMM_RESERVE_PRECISION);
-            cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
-            cappedAltEst = cappedAltEst
-                .mul(numericConstants_1.MARK_PRICE_PRECISION)
-                .mul(new anchor_1.BN(100))
-                .div(oracleTwapWithMantissa)
-                .mul(periodAdjustment);
-            if (cappedAltEst.abs().gte(interpEst.abs())) {
-                cappedAltEst = interpEst;
-            }
-        }
-        else {
-            cappedAltEst = interpEst;
-        }
-        return [
-            markTwapWithMantissa,
-            oracleTwapWithMantissa,
-            lowerboundEst,
-            cappedAltEst,
-            interpEst,
-        ];
-    });
-}
-exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
-/**
- *
- * @param market
- * @param oraclePriceData
- * @param periodAdjustment
- * @param estimationMethod
- * @returns Estimated funding rate. : Precision //TODO-PRECISION
- */
-function calculateEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1), estimationMethod) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [_1, _2, lowerboundEst, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-        if (estimationMethod == 'lowerbound') {
-            //assuming remaining funding period has no gap
-            return lowerboundEst;
-        }
-        else if (estimationMethod == 'capped') {
-            return cappedAltEst;
-        }
-        else {
-            return interpEst;
-        }
-    });
-}
-exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
-/**
- *
- * @param market
- * @param oraclePriceData
- * @param periodAdjustment
- * @returns Estimated funding rate. : Precision //TODO-PRECISION
- */
-function calculateLongShortFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [_1, _2, _, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
-            return [cappedAltEst, interpEst];
-        }
-        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
-            return [interpEst, cappedAltEst];
-        }
-        else {
-            return [interpEst, interpEst];
-        }
-    });
-}
-exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
-/**
- *
- * @param market
- * @param oraclePriceData
- * @param periodAdjustment
- * @returns Estimated funding rate. : Precision //TODO-PRECISION
- */
-function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-            return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
-        }
-        else if (market.baseAssetAmountLong.lt(market.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;