@drift-labs/sdk 0.2.0-master.26 → 0.2.0-master.27

package/src/math/repeg.js

@@ -1,9 +1,9 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateBudgetedKBN = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
-var anchor_1 = require("@project-serum/anchor");
-var assert_1 = require("../assert/assert");
-var numericConstants_1 = require("../constants/numericConstants");
+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
@@ -13,13 +13,13 @@ var numericConstants_1 = require("../constants/numericConstants");
  */
 function calculateAdjustKCost(amm, numerator, denomenator) {
     // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    var x = amm.baseAssetReserve;
-    var y = amm.quoteAssetReserve;
-    var d = amm.netBaseAssetAmount;
-    var Q = amm.pegMultiplier;
-    var quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
-    var p = numerator.mul(numericConstants_1.MARK_PRICE_PRECISION).div(denomenator);
-    var cost = quoteScale
+    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)
@@ -38,8 +38,8 @@ exports.calculateAdjustKCost = calculateAdjustKCost;
  * @returns cost : Precision QUOTE_ASSET_PRECISION
  */
 function calculateRepegCost(amm, newPeg) {
-    var dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
-    var cost = dqar
+    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);
@@ -47,32 +47,32 @@ function calculateRepegCost(amm, newPeg) {
 }
 exports.calculateRepegCost = calculateRepegCost;
 function calculateBudgetedKBN(x, y, budget, Q, d) {
-    (0, assert_1.assert)(Q.gt(new anchor_1.BN(0)));
-    var C = budget.mul(new anchor_1.BN(-1));
-    var dSign = new anchor_1.BN(1);
+    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);
     }
-    var pegged_y_d_d = y
+    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);
-    var numer1 = pegged_y_d_d;
-    var numer2 = C.mul(d)
+    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);
-    var denom1 = C.mul(x)
+    const denom1 = C.mul(x)
         .mul(x.add(d))
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.QUOTE_PRECISION);
-    var denom2 = pegged_y_d_d;
-    var numerator = numer1.sub(numer2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    var denominator = denom1.add(denom2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    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;
@@ -90,11 +90,11 @@ function calculateBudgetedK(amm, cost) {
     // = 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
-    var x = amm.baseAssetReserve;
-    var y = amm.quoteAssetReserve;
-    var d = amm.netBaseAssetAmount;
-    var Q = amm.pegMultiplier;
-    var _a = calculateBudgetedKBN(x, y, cost, Q, d), numerator = _a[0], denominator = _a[1];
+    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;
@@ -104,25 +104,25 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     // 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
-    var targetPeg = targetPrice
+    const targetPeg = targetPrice
         .mul(amm.baseAssetReserve)
         .div(amm.quoteAssetReserve)
         .div(numericConstants_1.PRICE_DIV_PEG);
-    var k = amm.sqrtK.mul(amm.sqrtK);
-    var x = amm.baseAssetReserve;
-    var y = amm.quoteAssetReserve;
-    var d = amm.netBaseAssetAmount;
-    var Q = amm.pegMultiplier;
-    var C = cost.mul(new anchor_1.BN(-1));
-    var deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    var pegChangeDirection = targetPeg.sub(Q);
-    var useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+    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;
     }
-    var deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    var newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    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/spotBalance.ts

@@ -19,6 +19,7 @@ import {
 	calculateSizeDiscountAssetWeight,
 	calculateSizePremiumLiabilityWeight,
 } from './margin';
+import { OraclePriceData } from '../oracles/types';
 
 export function getBalance(
 	tokenAmount: BN,
@@ -54,6 +55,31 @@ export function getTokenAmount(
 	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 
+export function getSignedTokenAmount(
+	tokenAmount: BN,
+	balanceType: SpotBalanceType
+): BN {
+	if (isVariant(balanceType, 'deposit')) {
+		return tokenAmount;
+	} else {
+		return tokenAmount.abs().neg();
+	}
+}
+
+export function getTokenValue(
+	tokenAmount: BN,
+	spotDecimals: number,
+	oraclePriceData: OraclePriceData
+): BN {
+	if (tokenAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	const precisionDecrease = TEN.pow(new BN(10 + spotDecimals - 6));
+
+	return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
+}
+
 export function calculateAssetWeight(
 	balanceAmount: BN,
 	spotMarket: SpotMarketAccount,

package/src/math/spotPosition.ts

@@ -1,6 +1,47 @@
-import { SpotPosition } from '../types';
+import { SpotMarketAccount, SpotPosition } from '../types';
 import { ZERO } from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import {
+	getSignedTokenAmount,
+	getTokenAmount,
+	getTokenValue,
+} from './spotBalance';
+import { OraclePriceData } from '../oracles/types';
 
 export function isSpotPositionAvailable(position: SpotPosition): boolean {
 	return position.balance.eq(ZERO) && position.openOrders === 0;
 }
+
+export function getWorstCaseTokenAmounts(
+	spotPosition: SpotPosition,
+	spotMarketAccount: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const tokenAmount = getSignedTokenAmount(
+		getTokenAmount(
+			spotPosition.balance,
+			spotMarketAccount,
+			spotPosition.balanceType
+		),
+		spotPosition.balanceType
+	);
+
+	const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
+	const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+
+	if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openBids.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+	} else {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openAsks.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+	}
+}

package/src/math/trade.js

@@ -1,15 +1,15 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
-var types_1 = require("../types");
-var anchor_1 = require("@project-serum/anchor");
-var assert_1 = require("../assert/assert");
-var numericConstants_1 = require("../constants/numericConstants");
-var market_1 = require("./market");
-var amm_1 = require("./amm");
-var utils_1 = require("./utils");
-var types_2 = require("../types");
-var MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
+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
@@ -27,55 +27,53 @@ var MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  *
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
-function calculateTradeSlippage(direction, amount, market, inputAssetType, oraclePriceData, useSpread) {
-    if (inputAssetType === void 0) { inputAssetType = 'quote'; }
-    if (useSpread === void 0) { useSpread = true; }
-    var oldPrice;
+function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
+    let oldPrice;
     if (useSpread && market.amm.baseSpread > 0) {
-        if ((0, types_2.isVariant)(direction, 'long')) {
-            oldPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+        if (types_2.isVariant(direction, 'long')) {
+            oldPrice = market_1.calculateAskPrice(market, oraclePriceData);
         }
         else {
-            oldPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+            oldPrice = market_1.calculateBidPrice(market, oraclePriceData);
         }
     }
     else {
-        oldPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+        oldPrice = market_1.calculateMarkPrice(market, oraclePriceData);
     }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    var _a = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread), acquiredBaseReserve = _a[0], acquiredQuoteReserve = _a[1], acquiredQuoteAssetAmount = _a[2];
-    var entryPrice = acquiredQuoteAssetAmount
+    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());
-    var amm;
+    let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        var _b = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _b.baseAssetReserve, quoteAssetReserve = _b.quoteAssetReserve, sqrtK = _b.sqrtK, newPeg = _b.newPeg;
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
         amm = {
-            baseAssetReserve: baseAssetReserve,
-            quoteAssetReserve: quoteAssetReserve,
+            baseAssetReserve,
+            quoteAssetReserve,
             sqrtK: sqrtK,
-            pegMultiplier: newPeg
+            pegMultiplier: newPeg,
         };
     }
     else {
         amm = market.amm;
     }
-    var newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
+    const newPrice = amm_1.calculatePrice(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
-        (0, assert_1.assert)(newPrice.lte(oldPrice));
+        assert_1.assert(newPrice.lte(oldPrice));
     }
     else {
-        (0, assert_1.assert)(oldPrice.lte(newPrice));
+        assert_1.assert(oldPrice.lte(newPrice));
     }
-    var pctMaxSlippage = newPrice
+    const pctMaxSlippage = newPrice
         .sub(oldPrice)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(oldPrice)
         .abs();
-    var pctAvgSlippage = entryPrice
+    const pctAvgSlippage = entryPrice
         .sub(oldPrice)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(oldPrice)
@@ -94,31 +92,29 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  * 	| '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, oraclePriceData, useSpread) {
-    if (inputAssetType === void 0) { inputAssetType = 'quote'; }
-    if (useSpread === void 0) { useSpread = true; }
+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];
     }
-    var swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
-    var amm;
+    const swapDirection = amm_1.getSwapDirection(inputAssetType, direction);
+    let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, sqrtK = _a.sqrtK, newPeg = _a.newPeg;
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
         amm = {
-            baseAssetReserve: baseAssetReserve,
-            quoteAssetReserve: quoteAssetReserve,
+            baseAssetReserve,
+            quoteAssetReserve,
             sqrtK: sqrtK,
-            pegMultiplier: newPeg
+            pegMultiplier: newPeg,
         };
     }
     else {
         amm = market.amm;
     }
-    var _b = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection), newQuoteAssetReserve = _b[0], newBaseAssetReserve = _b[1];
-    var acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
-    var acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    var acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
-    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
+    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;
 /**
@@ -138,36 +134,33 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  *   targetPrice => the target price MARK_PRICE_PRECISION
  * ]
  */
-function calculateTargetPriceTrade(market, targetPrice, pct, outputAssetType, oraclePriceData, useSpread) {
-    if (pct === void 0) { pct = MAXPCT; }
-    if (outputAssetType === void 0) { outputAssetType = 'quote'; }
-    if (useSpread === void 0) { useSpread = true; }
-    (0, assert_1.assert)(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
-    (0, assert_1.assert)(targetPrice.gt(numericConstants_1.ZERO));
-    (0, assert_1.assert)(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
-    var markPriceBefore = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
-    var bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
-    var askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
-    var direction;
+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)) {
-        var priceGap = targetPrice.sub(markPriceBefore);
-        var priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        const priceGap = targetPrice.sub(markPriceBefore);
+        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
         targetPrice = markPriceBefore.add(priceGapScaled);
         direction = types_1.PositionDirection.LONG;
     }
     else {
-        var priceGap = markPriceBefore.sub(targetPrice);
-        var priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        const priceGap = markPriceBefore.sub(targetPrice);
+        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
         targetPrice = markPriceBefore.sub(priceGapScaled);
         direction = types_1.PositionDirection.SHORT;
     }
-    var tradeSize;
-    var baseSize;
-    var baseAssetReserveBefore;
-    var quoteAssetReserveBefore;
-    var peg = market.amm.pegMultiplier;
+    let tradeSize;
+    let baseSize;
+    let baseAssetReserveBefore;
+    let quoteAssetReserveBefore;
+    let peg = market.amm.pegMultiplier;
     if (useSpread && market.amm.baseSpread > 0) {
-        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, newPeg = _a.newPeg;
+        const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
         baseAssetReserveBefore = baseAssetReserve;
         quoteAssetReserveBefore = quoteAssetReserve;
         peg = newPeg;
@@ -176,12 +169,12 @@ function calculateTargetPriceTrade(market, targetPrice, pct, outputAssetType, or
         baseAssetReserveBefore = market.amm.baseAssetReserve;
         quoteAssetReserveBefore = market.amm.quoteAssetReserve;
     }
-    var invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-    var k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
-    var baseAssetReserveAfter;
-    var quoteAssetReserveAfter;
-    var biasModifier = new anchor_1.BN(1);
-    var markPriceAfter;
+    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)) {
@@ -197,11 +190,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct, outputAssetType, or
     }
     else if (markPriceBefore.gt(targetPrice)) {
         // overestimate y2
-        baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
+        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 = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
             .sub(quoteAssetReserveAfter)
@@ -212,11 +205,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct, outputAssetType, or
     }
     else if (markPriceBefore.lt(targetPrice)) {
         // underestimate y2
-        baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
+        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 = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
             .sub(quoteAssetReserveBefore)
@@ -231,20 +224,20 @@ function calculateTargetPriceTrade(market, targetPrice, pct, outputAssetType, or
         tradeSize = numericConstants_1.ZERO;
         return [direction, tradeSize, targetPrice, targetPrice];
     }
-    var tp1 = targetPrice;
-    var tp2 = markPriceAfter;
-    var originalDiff = targetPrice.sub(markPriceBefore);
+    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);
     }
-    var entryPrice = tradeSize
+    const entryPrice = tradeSize
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(baseSize.abs());
-    (0, assert_1.assert)(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
-    (0, assert_1.assert)(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
+    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() +

package/src/math/utils.js

@@ -1,16 +1,15 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.squareRootBN = void 0;
-var __1 = require("../");
-var squareRootBN = function (n, closeness) {
-    if (closeness === void 0) { closeness = new __1.BN(1); }
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
     // Assuming the sqrt of n as n only
-    var x = n;
+    let x = n;
     // The closed guess will be stored in the root
-    var root;
+    let root;
     // To count the number of iterations
-    var count = 0;
-    var TWO = new __1.BN(2);
+    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++;

package/src/math/utils.js.map

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