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

package/src/math/spotBalance.ts

@@ -0,0 +1,290 @@
+import {
+	SpotMarketAccount,
+	SpotBalanceType,
+	isVariant,
+	MarginCategory,
+} from '../types';
+import { BN } from '@project-serum/anchor';
+import {
+	SPOT_MARKET_UTILIZATION_PRECISION,
+	ONE,
+	TEN,
+	ZERO,
+	SPOT_MARKET_INTEREST_PRECISION,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	ONE_YEAR,
+	AMM_RESERVE_PRECISION,
+} from '../constants/numericConstants';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
+
+export function getBalance(
+	tokenAmount: BN,
+	spotMarket: SpotMarketAccount,
+	balanceType: SpotBalanceType
+): BN {
+	const precisionIncrease = TEN.pow(new BN(16 - spotMarket.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? spotMarket.cumulativeDepositInterest
+		: spotMarket.cumulativeBorrowInterest;
+
+	let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+
+	if (!balance.eq(ZERO) && isVariant(balanceType, 'borrow')) {
+		balance = balance.add(ONE);
+	}
+
+	return balance;
+}
+
+export function getTokenAmount(
+	balanceAmount: BN,
+	spotMarket: SpotMarketAccount,
+	balanceType: SpotBalanceType
+): BN {
+	const precisionDecrease = TEN.pow(new BN(16 - spotMarket.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? spotMarket.cumulativeDepositInterest
+		: spotMarket.cumulativeBorrowInterest;
+
+	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+
+export function calculateAssetWeight(
+	balanceAmount: BN,
+	spotMarket: SpotMarketAccount,
+	marginCategory: MarginCategory
+): BN {
+	const sizePrecision = TEN.pow(new BN(spotMarket.decimals));
+	let sizeInAmmReservePrecision;
+	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
+		sizeInAmmReservePrecision = balanceAmount.div(
+			sizePrecision.div(AMM_RESERVE_PRECISION)
+		);
+	} else {
+		sizeInAmmReservePrecision = balanceAmount
+			.mul(AMM_RESERVE_PRECISION)
+			.div(sizePrecision);
+	}
+
+	let assetWeight;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				spotMarket.imfFactor,
+				spotMarket.initialAssetWeight
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				spotMarket.imfFactor,
+				spotMarket.maintenanceAssetWeight
+			);
+			break;
+		default:
+			assetWeight = spotMarket.initialAssetWeight;
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateLiabilityWeight(
+	balanceAmount: BN,
+	spotMarket: SpotMarketAccount,
+	marginCategory: MarginCategory
+): BN {
+	const sizePrecision = TEN.pow(new BN(spotMarket.decimals));
+	let sizeInAmmReservePrecision;
+	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
+		sizeInAmmReservePrecision = balanceAmount.div(
+			sizePrecision.div(AMM_RESERVE_PRECISION)
+		);
+	} else {
+		sizeInAmmReservePrecision = balanceAmount
+			.mul(AMM_RESERVE_PRECISION)
+			.div(sizePrecision);
+	}
+
+	let assetWeight;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				spotMarket.imfFactor,
+				spotMarket.initialLiabilityWeight,
+				SPOT_MARKET_WEIGHT_PRECISION
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				spotMarket.imfFactor,
+				spotMarket.maintenanceLiabilityWeight,
+				SPOT_MARKET_WEIGHT_PRECISION
+			);
+			break;
+		default:
+			assetWeight = spotMarket.initialLiabilityWeight;
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateUtilization(bank: SpotMarketAccount): BN {
+	const tokenDepositAmount = getTokenAmount(
+		bank.depositBalance,
+		bank,
+		SpotBalanceType.DEPOSIT
+	);
+	const tokenBorrowAmount = getTokenAmount(
+		bank.borrowBalance,
+		bank,
+		SpotBalanceType.BORROW
+	);
+
+	let utilization: BN;
+	if (tokenBorrowAmount.eq(ZERO) && tokenDepositAmount.eq(ZERO)) {
+		utilization = ZERO;
+	} else if (tokenDepositAmount.eq(ZERO)) {
+		utilization = SPOT_MARKET_UTILIZATION_PRECISION;
+	} else {
+		utilization = tokenBorrowAmount
+			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+			.div(tokenDepositAmount);
+	}
+
+	return utilization;
+}
+
+export function calculateInterestRate(bank: SpotMarketAccount): BN {
+	const utilization = calculateUtilization(bank);
+
+	let interestRate: BN;
+	if (utilization.gt(bank.optimalUtilization)) {
+		const surplusUtilization = utilization.sub(bank.optimalUtilization);
+		const borrowRateSlope = bank.maxBorrowRate
+			.sub(bank.optimalBorrowRate)
+			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+			.div(SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+
+		interestRate = bank.optimalBorrowRate.add(
+			surplusUtilization
+				.mul(borrowRateSlope)
+				.div(SPOT_MARKET_UTILIZATION_PRECISION)
+		);
+	} else {
+		const borrowRateSlope = bank.optimalBorrowRate
+			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+			.div(SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+
+		interestRate = utilization
+			.mul(borrowRateSlope)
+			.div(SPOT_MARKET_UTILIZATION_PRECISION);
+	}
+
+	return interestRate;
+}
+
+export function calculateDepositRate(bank: SpotMarketAccount): BN {
+	const utilization = calculateUtilization(bank);
+	const borrowRate = calculateBorrowRate(bank);
+	const depositRate = borrowRate
+		.mul(utilization)
+		.div(SPOT_MARKET_UTILIZATION_PRECISION);
+	return depositRate;
+}
+
+export function calculateBorrowRate(bank: SpotMarketAccount): BN {
+	return calculateInterestRate(bank);
+}
+
+export function calculateInterestAccumulated(
+	bank: SpotMarketAccount,
+	now: BN
+): { borrowInterest: BN; depositInterest: BN } {
+	const interestRate = calculateInterestRate(bank);
+
+	const timeSinceLastUpdate = now.sub(bank.lastInterestTs);
+
+	const modifiedBorrowRate = interestRate.mul(timeSinceLastUpdate);
+
+	const utilization = calculateUtilization(bank);
+
+	const modifiedDepositRate = modifiedBorrowRate
+		.mul(utilization)
+		.div(SPOT_MARKET_UTILIZATION_PRECISION);
+
+	const borrowInterest = bank.cumulativeBorrowInterest
+		.mul(modifiedBorrowRate)
+		.div(ONE_YEAR)
+		.div(SPOT_MARKET_INTEREST_PRECISION)
+		.add(ONE);
+	const depositInterest = bank.cumulativeDepositInterest
+		.mul(modifiedDepositRate)
+		.div(ONE_YEAR)
+		.div(SPOT_MARKET_INTEREST_PRECISION);
+
+	return { borrowInterest, depositInterest };
+}
+
+export function calculateWithdrawLimit(
+	spotMarket: SpotMarketAccount,
+	now: BN
+): { borrowLimit: BN; withdrawLimit: BN } {
+	const marketDepositTokenAmount = getTokenAmount(
+		spotMarket.depositBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	const marketBorrowTokenAmount = getTokenAmount(
+		spotMarket.borrowBalance,
+		spotMarket,
+		SpotBalanceType.BORROW
+	);
+
+	const twentyFourHours = new BN(60 * 60 * 24);
+	const sinceLast = now.sub(spotMarket.lastTwapTs);
+	const sinceStart = BN.max(ZERO, twentyFourHours.sub(sinceLast));
+	const borrowTokenTwapLive = spotMarket.borrowTokenTwap
+		.mul(sinceStart)
+		.add(marketBorrowTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceLast));
+
+	const depositTokenTwapLive = spotMarket.depositTokenTwap
+		.mul(sinceStart)
+		.add(marketDepositTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceLast));
+
+	const maxBorrowTokens = BN.min(
+		BN.max(
+			marketDepositTokenAmount.div(new BN(6)),
+			borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
+		),
+		marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new BN(10)))
+	); // between ~15-90% utilization with friction on twap
+
+	const minDepositTokens = depositTokenTwapLive.sub(
+		BN.min(
+			BN.max(
+				depositTokenTwapLive.div(new BN(5)),
+				spotMarket.withdrawGuardThreshold
+			),
+			depositTokenTwapLive
+		)
+	);
+
+	return {
+		borrowLimit: maxBorrowTokens.sub(marketBorrowTokenAmount),
+		withdrawLimit: marketDepositTokenAmount.sub(minDepositTokens),
+	};
+}

package/src/math/spotMarket.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+exports.castNumberToSpotPrecision = void 0;
+var anchor_1 = require("@project-serum/anchor");
+function castNumberToSpotPrecision(value, spotMarket) {
+    return new anchor_1.BN(value * Math.pow(10, spotMarket.decimals));
+}
+exports.castNumberToSpotPrecision = castNumberToSpotPrecision;

package/src/math/spotMarket.ts

@@ -0,0 +1,9 @@
+import { BN } from '@project-serum/anchor';
+import { SpotMarketAccount } from '../types';
+
+export function castNumberToSpotPrecision(
+	value: number,
+	spotMarket: SpotMarketAccount
+): BN {
+	return new BN(value * Math.pow(10, spotMarket.decimals));
+}

package/src/math/spotPosition.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+exports.isSpotPositionAvailable = void 0;
+var numericConstants_1 = require("../constants/numericConstants");
+function isSpotPositionAvailable(position) {
+    return position.balance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+}
+exports.isSpotPositionAvailable = isSpotPositionAvailable;

package/src/math/spotPosition.ts

@@ -0,0 +1,6 @@
+import { SpotPosition } from '../types';
+import { ZERO } from '../constants/numericConstants';
+
+export function isSpotPositionAvailable(position: SpotPosition): boolean {
+	return position.balance.eq(ZERO) && position.openOrders === 0;
+}

package/src/math/state.ts

@@ -8,7 +8,7 @@ import { StateAccount } from '../types';
  */
 export function getExchangeFee(state: StateAccount): number {
 	const exchangeFee =
-		state.feeStructure.feeNumerator.toNumber() /
-		state.feeStructure.feeDenominator.toNumber();
+		state.perpFeeStructure.feeNumerator.toNumber() /
+		state.perpFeeStructure.feeDenominator.toNumber();
 	return exchangeFee;
 }

package/src/math/trade.js

@@ -1,15 +1,15 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = 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]
+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]
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
  * @param direction
@@ -27,53 +27,55 @@ const 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 = 'quote', oraclePriceData, useSpread = true) {
-    let oldPrice;
+function calculateTradeSlippage(direction, amount, market, inputAssetType, oraclePriceData, useSpread) {
+    if (inputAssetType === void 0) { inputAssetType = 'quote'; }
+    if (useSpread === void 0) { useSpread = true; }
+    var oldPrice;
     if (useSpread && market.amm.baseSpread > 0) {
-        if (types_2.isVariant(direction, 'long')) {
-            oldPrice = market_1.calculateAskPrice(market, oraclePriceData);
+        if ((0, types_2.isVariant)(direction, 'long')) {
+            oldPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
         }
         else {
-            oldPrice = market_1.calculateBidPrice(market, oraclePriceData);
+            oldPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
         }
     }
     else {
-        oldPrice = market_1.calculateMarkPrice(market, oraclePriceData);
+        oldPrice = (0, 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
+    var _a = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread), acquiredBaseReserve = _a[0], acquiredQuoteReserve = _a[1], acquiredQuoteAssetAmount = _a[2];
+    var entryPrice = acquiredQuoteAssetAmount
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(acquiredBaseReserve.abs());
-    let amm;
+    var amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        var _b = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _b.baseAssetReserve, quoteAssetReserve = _b.quoteAssetReserve, sqrtK = _b.sqrtK, newPeg = _b.newPeg;
         amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
+            baseAssetReserve: baseAssetReserve,
+            quoteAssetReserve: quoteAssetReserve,
             sqrtK: sqrtK,
-            pegMultiplier: newPeg,
+            pegMultiplier: newPeg
         };
     }
     else {
         amm = market.amm;
     }
-    const newPrice = amm_1.calculatePrice(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
+    var newPrice = (0, 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));
+        (0, assert_1.assert)(newPrice.lte(oldPrice));
     }
     else {
-        assert_1.assert(oldPrice.lte(newPrice));
+        (0, assert_1.assert)(oldPrice.lte(newPrice));
     }
-    const pctMaxSlippage = newPrice
+    var pctMaxSlippage = newPrice
         .sub(oldPrice)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(oldPrice)
         .abs();
-    const pctAvgSlippage = entryPrice
+    var pctAvgSlippage = entryPrice
         .sub(oldPrice)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(oldPrice)
@@ -92,29 +94,31 @@ 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 = 'quote', oraclePriceData, useSpread = true) {
+function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread) {
+    if (inputAssetType === void 0) { inputAssetType = 'quote'; }
+    if (useSpread === void 0) { 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;
+    var swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
+    var amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, sqrtK = _a.sqrtK, newPeg = _a.newPeg;
         amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
+            baseAssetReserve: baseAssetReserve,
+            quoteAssetReserve: quoteAssetReserve,
             sqrtK: sqrtK,
-            pegMultiplier: newPeg,
+            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];
+    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];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**
@@ -134,33 +138,36 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  *   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;
+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;
     if (targetPrice.gt(markPriceBefore)) {
-        const priceGap = targetPrice.sub(markPriceBefore);
-        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        var priceGap = targetPrice.sub(markPriceBefore);
+        var 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);
+        var priceGap = markPriceBefore.sub(targetPrice);
+        var 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;
+    var tradeSize;
+    var baseSize;
+    var baseAssetReserveBefore;
+    var quoteAssetReserveBefore;
+    var peg = market.amm.pegMultiplier;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, newPeg = _a.newPeg;
         baseAssetReserveBefore = baseAssetReserve;
         quoteAssetReserveBefore = quoteAssetReserve;
         peg = newPeg;
@@ -169,12 +176,12 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         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;
+    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;
     if (useSpread &&
         targetPrice.lt(askPriceBefore) &&
         targetPrice.gt(bidPriceBefore)) {
@@ -190,11 +197,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     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));
+        baseAssetReserveAfter = (0, 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);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
             .sub(quoteAssetReserveAfter)
@@ -205,11 +212,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     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));
+        baseAssetReserveAfter = (0, 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);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
             .sub(quoteAssetReserveBefore)
@@ -224,20 +231,20 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         tradeSize = numericConstants_1.ZERO;
         return [direction, tradeSize, targetPrice, targetPrice];
     }
-    let tp1 = targetPrice;
-    let tp2 = markPriceAfter;
-    let originalDiff = targetPrice.sub(markPriceBefore);
+    var tp1 = targetPrice;
+    var tp2 = markPriceAfter;
+    var originalDiff = targetPrice.sub(markPriceBefore);
     if (direction == types_1.PositionDirection.SHORT) {
         tp1 = markPriceAfter;
         tp2 = targetPrice;
         originalDiff = markPriceBefore.sub(targetPrice);
     }
-    const entryPrice = tradeSize
+    var 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' +
+    (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' +
         tp2.toString() +
         '>=' +
         tp1.toString() +

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -59,7 +59,7 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData?: OraclePriceData,
 	useSpread = true
@@ -147,7 +147,7 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
@@ -204,7 +204,7 @@ export function calculateTradeAcquiredAmounts(
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',

package/src/math/utils.js

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