@drift-labs/sdk 0.2.0-master.29 → 0.2.0-master.30

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;

package/src/math/repeg.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateBudgetedKBN = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const assert_1 = require("../assert/assert");
-const numericConstants_1 = require("../constants/numericConstants");
-/**
- * Helper function calculating adjust k cost
- * @param amm
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateAdjustKCost(amm, numerator, denomenator) {
-    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
-    const Q = amm.pegMultiplier;
-    const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
-    const p = numerator.mul(numericConstants_1.MARK_PRICE_PRECISION).div(denomenator);
-    const cost = quoteScale
-        .div(x.add(d))
-        .sub(quoteScale
-        .mul(p)
-        .div(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(x.mul(p).div(numericConstants_1.MARK_PRICE_PRECISION).add(d)))
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .div(numericConstants_1.PEG_PRECISION);
-    return cost.mul(new anchor_1.BN(-1));
-}
-exports.calculateAdjustKCost = calculateAdjustKCost;
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param amm
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-function calculateRepegCost(amm, newPeg) {
-    const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
-    const cost = dqar
-        .mul(newPeg.sub(amm.pegMultiplier))
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .div(numericConstants_1.PEG_PRECISION);
-    return cost;
-}
-exports.calculateRepegCost = calculateRepegCost;
-function calculateBudgetedKBN(x, y, budget, Q, d) {
-    assert_1.assert(Q.gt(new anchor_1.BN(0)));
-    const C = budget.mul(new anchor_1.BN(-1));
-    let dSign = new anchor_1.BN(1);
-    if (d.lt(new anchor_1.BN(0))) {
-        dSign = new anchor_1.BN(-1);
-    }
-    const pegged_y_d_d = y
-        .mul(d)
-        .mul(d)
-        .mul(Q)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.PEG_PRECISION);
-    const numer1 = pegged_y_d_d;
-    const numer2 = C.mul(d)
-        .div(numericConstants_1.QUOTE_PRECISION)
-        .mul(x.add(d))
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .mul(dSign);
-    const denom1 = C.mul(x)
-        .mul(x.add(d))
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.QUOTE_PRECISION);
-    const denom2 = pegged_y_d_d;
-    const numerator = numer1.sub(numer2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    const denominator = denom1.add(denom2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    return [numerator, denominator];
-}
-exports.calculateBudgetedKBN = calculateBudgetedKBN;
-function calculateBudgetedK(amm, cost) {
-    // wolframalpha.com
-    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
-    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
-    // numer
-    //   =  y*d*d*Q - Cxd - Cdd
-    //   =  y/x*Q*d*d - Cd - Cd/x
-    //   = mark      - C/d - C/(x)
-    //   =  mark/C    - 1/d - 1/x
-    // denom
-    // = C*x*x + C*x*d + y*d*d*Q
-    // = x/d**2 + 1 / d + mark/C
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
-    const Q = amm.pegMultiplier;
-    const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
-    return [numerator, denominator];
-}
-exports.calculateBudgetedK = calculateBudgetedK;
-function calculateBudgetedPeg(amm, cost, targetPrice) {
-    // wolframalpha.com
-    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
-    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    const targetPeg = targetPrice
-        .mul(amm.baseAssetReserve)
-        .div(amm.quoteAssetReserve)
-        .div(numericConstants_1.PRICE_DIV_PEG);
-    const k = amm.sqrtK.mul(amm.sqrtK);
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
-    const Q = amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    const pegChangeDirection = targetPeg.sub(Q);
-    const useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
-        (deltaQuoteAssetReserves.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
-    if (deltaQuoteAssetReserves.eq(numericConstants_1.ZERO) || useTargetPeg) {
-        return targetPeg;
-    }
-    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
-    return newPeg;
-}
-exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/src/math/trade.js

@@ -1,253 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
-const types_1 = require("../types");
-const anchor_1 = require("@project-serum/anchor");
-const assert_1 = require("../assert/assert");
-const numericConstants_1 = require("../constants/numericConstants");
-const market_1 = require("./market");
-const amm_1 = require("./amm");
-const utils_1 = require("./utils");
-const types_2 = require("../types");
-const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
-/**
- * Calculates avg/max slippage (price impact) for candidate trade
- * @param direction
- * @param amount
- * @param market
- * @param inputAssetType which asset is being traded
- * @param useSpread whether to consider spread with calculating slippage
- * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
- *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
- *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
- *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
- *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
- */
-function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
-    let oldPrice;
-    if (useSpread && market.amm.baseSpread > 0) {
-        if (types_2.isVariant(direction, 'long')) {
-            oldPrice = market_1.calculateAskPrice(market, oraclePriceData);
-        }
-        else {
-            oldPrice = market_1.calculateBidPrice(market, oraclePriceData);
-        }
-    }
-    else {
-        oldPrice = market_1.calculateMarkPrice(market, oraclePriceData);
-    }
-    if (amount.eq(numericConstants_1.ZERO)) {
-        return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
-    }
-    const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
-    const entryPrice = acquiredQuoteAssetAmount
-        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(acquiredBaseReserve.abs());
-    let amm;
-    if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: sqrtK,
-            pegMultiplier: newPeg,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const newPrice = amm_1.calculatePrice(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
-    if (direction == types_1.PositionDirection.SHORT) {
-        assert_1.assert(newPrice.lte(oldPrice));
-    }
-    else {
-        assert_1.assert(oldPrice.lte(newPrice));
-    }
-    const pctMaxSlippage = newPrice
-        .sub(oldPrice)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(oldPrice)
-        .abs();
-    const pctAvgSlippage = entryPrice
-        .sub(oldPrice)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(oldPrice)
-        .abs();
-    return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice];
-}
-exports.calculateTradeSlippage = calculateTradeSlippage;
-/**
- * Calculates acquired amounts for trade executed
- * @param direction
- * @param amount
- * @param market
- * @param inputAssetType
- * @param useSpread
- * @return
- * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
- * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
- */
-function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
-    if (amount.eq(numericConstants_1.ZERO)) {
-        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
-    }
-    const swapDirection = amm_1.getSwapDirection(inputAssetType, direction);
-    let amm;
-    if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: sqrtK,
-            pegMultiplier: newPeg,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(amm, inputAssetType, amount, swapDirection);
-    const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
-    const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    const acquiredQuoteAssetamount = amm_1.calculateQuoteAssetAmountSwapped(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
-    return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
-}
-exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
-/**
- * calculateTargetPriceTrade
- * simple function for finding arbitraging trades
- * @param market
- * @param targetPrice
- * @param pct optional default is 100% gap filling, can set smaller.
- * @param outputAssetType which asset to trade.
- * @param useSpread whether or not to consider the spread when calculating the trade size
- * @returns trade direction/size in order to push price to a targetPrice,
- *
- * [
- *   direction => direction of trade required, PositionDirection
- *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
- * ]
- */
-function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', oraclePriceData, useSpread = true) {
-    assert_1.assert(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
-    assert_1.assert(targetPrice.gt(numericConstants_1.ZERO));
-    assert_1.assert(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
-    const markPriceBefore = market_1.calculateMarkPrice(market, oraclePriceData);
-    const bidPriceBefore = market_1.calculateBidPrice(market, oraclePriceData);
-    const askPriceBefore = market_1.calculateAskPrice(market, oraclePriceData);
-    let direction;
-    if (targetPrice.gt(markPriceBefore)) {
-        const priceGap = targetPrice.sub(markPriceBefore);
-        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-        targetPrice = markPriceBefore.add(priceGapScaled);
-        direction = types_1.PositionDirection.LONG;
-    }
-    else {
-        const priceGap = markPriceBefore.sub(targetPrice);
-        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-        targetPrice = markPriceBefore.sub(priceGapScaled);
-        direction = types_1.PositionDirection.SHORT;
-    }
-    let tradeSize;
-    let baseSize;
-    let baseAssetReserveBefore;
-    let quoteAssetReserveBefore;
-    let peg = market.amm.pegMultiplier;
-    if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
-        baseAssetReserveBefore = baseAssetReserve;
-        quoteAssetReserveBefore = quoteAssetReserve;
-        peg = newPeg;
-    }
-    else {
-        baseAssetReserveBefore = market.amm.baseAssetReserve;
-        quoteAssetReserveBefore = market.amm.quoteAssetReserve;
-    }
-    const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
-    let baseAssetReserveAfter;
-    let quoteAssetReserveAfter;
-    const biasModifier = new anchor_1.BN(1);
-    let markPriceAfter;
-    if (useSpread &&
-        targetPrice.lt(askPriceBefore) &&
-        targetPrice.gt(bidPriceBefore)) {
-        // no trade, market is at target
-        if (markPriceBefore.gt(targetPrice)) {
-            direction = types_1.PositionDirection.SHORT;
-        }
-        else {
-            direction = types_1.PositionDirection.LONG;
-        }
-        tradeSize = numericConstants_1.ZERO;
-        return [direction, tradeSize, targetPrice, targetPrice];
-    }
-    else if (markPriceBefore.gt(targetPrice)) {
-        // overestimate y2
-        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
-        quoteAssetReserveAfter = k
-            .div(numericConstants_1.MARK_PRICE_PRECISION)
-            .div(baseAssetReserveAfter);
-        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
-        direction = types_1.PositionDirection.SHORT;
-        tradeSize = quoteAssetReserveBefore
-            .sub(quoteAssetReserveAfter)
-            .mul(peg)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-        baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
-    }
-    else if (markPriceBefore.lt(targetPrice)) {
-        // underestimate y2
-        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
-        quoteAssetReserveAfter = k
-            .div(numericConstants_1.MARK_PRICE_PRECISION)
-            .div(baseAssetReserveAfter);
-        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
-        direction = types_1.PositionDirection.LONG;
-        tradeSize = quoteAssetReserveAfter
-            .sub(quoteAssetReserveBefore)
-            .mul(peg)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-        baseSize = baseAssetReserveBefore.sub(baseAssetReserveAfter);
-    }
-    else {
-        // no trade, market is at target
-        direction = types_1.PositionDirection.LONG;
-        tradeSize = numericConstants_1.ZERO;
-        return [direction, tradeSize, targetPrice, targetPrice];
-    }
-    let tp1 = targetPrice;
-    let tp2 = markPriceAfter;
-    let originalDiff = targetPrice.sub(markPriceBefore);
-    if (direction == types_1.PositionDirection.SHORT) {
-        tp1 = markPriceAfter;
-        tp2 = targetPrice;
-        originalDiff = markPriceBefore.sub(targetPrice);
-    }
-    const entryPrice = tradeSize
-        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(baseSize.abs());
-    assert_1.assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
-    assert_1.assert(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
-        tp2.toString() +
-        '>=' +
-        tp1.toString() +
-        'err: ' +
-        tp2.sub(tp1).abs().toString());
-    if (outputAssetType == 'quote') {
-        return [direction, tradeSize, entryPrice, targetPrice];
-    }
-    else {
-        return [direction, baseSize, entryPrice, targetPrice];
-    }
-}
-exports.calculateTargetPriceTrade = calculateTargetPriceTrade;

package/src/math/utils.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.squareRootBN = void 0;
-const __1 = require("../");
-const squareRootBN = (n, closeness = new __1.BN(1)) => {
-    // Assuming the sqrt of n as n only
-    let x = n;
-    // The closed guess will be stored in the root
-    let root;
-    // To count the number of iterations
-    let count = 0;
-    const TWO = new __1.BN(2);
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    while (count < Number.MAX_SAFE_INTEGER) {
-        count++;
-        // Calculate more closed x
-        root = x.add(n.div(x)).div(TWO);
-        // Check for closeness
-        if (x.sub(root).abs().lte(closeness))
-            break;
-        // Update root
-        x = root;
-    }
-    return root;
-};
-exports.squareRootBN = squareRootBN;

package/src/math/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/oracles/oracleClientCache.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OracleClientCache = void 0;
-const oracleClient_1 = require("../factory/oracleClient");
-class OracleClientCache {
-    constructor() {
-        this.cache = new Map();
-    }
-    get(oracleSource, connection) {
-        const key = Object.keys(oracleSource)[0];
-        if (this.cache.has(key)) {
-            return this.cache.get(key);
-        }
-        const client = oracleClient_1.getOracleClient(oracleSource, connection);
-        this.cache.set(key, client);
-        return client;
-    }
-}
-exports.OracleClientCache = OracleClientCache;