@drift-labs/sdk 2.20.0-beta.0 → 2.20.0-beta.1

package/lib/math/market.js

@@ -15,8 +15,8 @@ const assert_1 = require("../assert/assert");
  * @return markPrice : Precision PRICE_PRECISION
  */
 function calculateReservePrice(market, oraclePriceData) {
-    const newAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
-    return amm_1.calculatePrice(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
+    const newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    return (0, amm_1.calculatePrice)(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
 }
 exports.calculateReservePrice = calculateReservePrice;
 /**
@@ -26,8 +26,8 @@ exports.calculateReservePrice = calculateReservePrice;
  * @return bidPrice : Precision PRICE_PRECISION
  */
 function calculateBidPrice(market, oraclePriceData) {
-    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
-    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
+    return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 exports.calculateBidPrice = calculateBidPrice;
 /**
@@ -37,12 +37,12 @@ exports.calculateBidPrice = calculateBidPrice;
  * @return askPrice : Precision PRICE_PRECISION
  */
 function calculateAskPrice(market, oraclePriceData) {
-    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
-    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
+    return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 exports.calculateAskPrice = calculateAskPrice;
 function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
-    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', baseAssetAmount.abs(), amm_1.getSwapDirection('base', direction));
+    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', direction));
     const newAmm = Object.assign({}, market.amm);
     const newMarket = Object.assign({}, market);
     newMarket.amm = newAmm;
@@ -64,11 +64,11 @@ function calculateMarketMarginRatio(market, size, marginCategory) {
     let marginRatio;
     switch (marginCategory) {
         case 'Initial': {
-            marginRatio = margin_1.calculateSizePremiumLiabilityWeight(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
         }
         case 'Maintenance': {
-            marginRatio = margin_1.calculateSizePremiumLiabilityWeight(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioMaintenance), numericConstants_1.MARGIN_PRECISION).toNumber();
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioMaintenance), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
         }
     }
@@ -88,7 +88,7 @@ function calculateUnrealizedAssetWeight(market, quoteSpotMarket, unrealizedPnl,
                         .div(netUnsettledPnl);
                 }
             }
-            assetWeight = margin_1.calculateSizeDiscountAssetWeight(unrealizedPnl, new anchor_1.BN(market.unrealizedPnlImfFactor), assetWeight);
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, new anchor_1.BN(market.unrealizedPnlImfFactor), assetWeight);
             break;
         case 'Maintenance':
             assetWeight = new anchor_1.BN(market.unrealizedPnlMaintenanceAssetWeight);
@@ -98,14 +98,14 @@ function calculateUnrealizedAssetWeight(market, quoteSpotMarket, unrealizedPnl,
 }
 exports.calculateUnrealizedAssetWeight = calculateUnrealizedAssetWeight;
 function calculateMarketAvailablePNL(perpMarket, spotMarket) {
-    return spotBalance_1.getTokenAmount(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
 }
 exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
 function calculateMarketMaxAvailableInsurance(perpMarket, spotMarket) {
-    assert_1.assert(spotMarket.marketIndex == numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+    (0, assert_1.assert)(spotMarket.marketIndex == numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
     // todo: insuranceFundAllocation technically not guaranteed to be in Insurance Fund
     const insuranceFundAllocation = perpMarket.insuranceClaim.quoteMaxInsurance.sub(perpMarket.insuranceClaim.quoteSettledInsurance);
-    const ammFeePool = spotBalance_1.getTokenAmount(perpMarket.amm.feePool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const ammFeePool = (0, spotBalance_1.getTokenAmount)(perpMarket.amm.feePool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
     return insuranceFundAllocation.add(ammFeePool);
 }
 exports.calculateMarketMaxAvailableInsurance = calculateMarketMaxAvailableInsurance;
@@ -121,13 +121,13 @@ function calculateNetUserPnl(perpMarket, oraclePriceData) {
 exports.calculateNetUserPnl = calculateNetUserPnl;
 function calculateNetUserPnlImbalance(perpMarket, spotMarket, oraclePriceData) {
     const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
-    const pnlPool = spotBalance_1.getTokenAmount(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const pnlPool = (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
     const imbalance = netUserPnl.sub(pnlPool);
     return imbalance;
 }
 exports.calculateNetUserPnlImbalance = calculateNetUserPnlImbalance;
 function calculateAvailablePerpLiquidity(market, oraclePriceData, dlob, slot) {
-    let [bids, asks] = amm_1.calculateMarketOpenBidAsk(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
+    let [bids, asks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
     asks = asks.abs();
     const bidPrice = calculateBidPrice(market, oraclePriceData);
     const askPrice = calculateAskPrice(market, oraclePriceData);

package/lib/math/oracles.js

@@ -9,7 +9,7 @@ function oraclePriceBands(market, oraclePriceData) {
     const offset = oraclePriceData.price
         .mul(new index_1.BN(maxPercentDiff))
         .div(numericConstants_1.MARGIN_PRECISION);
-    assert_1.assert(offset.gt(numericConstants_1.ZERO));
+    (0, assert_1.assert)(offset.gt(numericConstants_1.ZERO));
     return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
 }
 exports.oraclePriceBands = oraclePriceBands;

package/lib/math/orders.js

@@ -7,7 +7,7 @@ const anchor_1 = require("@project-serum/anchor");
 const auction_1 = require("./auction");
 const amm_1 = require("./amm");
 function isOrderRiskIncreasing(user, order) {
-    if (types_1.isVariant(order.status, 'init')) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
     }
     const position = user.getPerpPosition(order.marketIndex) ||
@@ -17,12 +17,12 @@ function isOrderRiskIncreasing(user, order) {
         return true;
     }
     // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
         return true;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'short')) {
+        (0, types_1.isVariant)(order.direction, 'short')) {
         return true;
     }
     const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
@@ -34,7 +34,7 @@ function isOrderRiskIncreasing(user, order) {
 }
 exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
 function isOrderRiskIncreasingInSameDirection(user, order) {
-    if (types_1.isVariant(order.status, 'init')) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
     }
     const position = user.getPerpPosition(order.marketIndex) ||
@@ -44,31 +44,31 @@ function isOrderRiskIncreasingInSameDirection(user, order) {
         return true;
     }
     // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
         return true;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'short')) {
+        (0, types_1.isVariant)(order.direction, 'short')) {
         return true;
     }
     return false;
 }
 exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
 function isOrderReduceOnly(user, order) {
-    if (types_1.isVariant(order.status, 'init')) {
+    if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
     }
     const position = user.getPerpPosition(order.marketIndex) ||
         user.getEmptyPosition(order.marketIndex);
     // if position is long and order is long
     if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'long')) {
+        (0, types_1.isVariant)(order.direction, 'long')) {
         return false;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'short')) {
+        (0, types_1.isVariant)(order.direction, 'short')) {
         return false;
     }
     return true;
@@ -82,7 +82,7 @@ exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
 function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
     let limitPrice;
     if (hasAuctionPrice(order, slot)) {
-        limitPrice = auction_1.getAuctionPrice(order, slot, oraclePriceData.price);
+        limitPrice = (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
     }
     else if (order.oraclePriceOffset !== 0) {
         limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
@@ -99,16 +99,16 @@ exports.getLimitPrice = getLimitPrice;
 function hasLimitPrice(order, slot) {
     return (order.price.gt(numericConstants_1.ZERO) ||
         order.oraclePriceOffset != 0 ||
-        !auction_1.isAuctionComplete(order, slot));
+        !(0, auction_1.isAuctionComplete)(order, slot));
 }
 exports.hasLimitPrice = hasLimitPrice;
 function hasAuctionPrice(order, slot) {
-    return (!auction_1.isAuctionComplete(order, slot) &&
+    return (!(0, auction_1.isAuctionComplete)(order, slot) &&
         (!order.auctionStartPrice.eq(numericConstants_1.ZERO) || !order.auctionEndPrice.eq(numericConstants_1.ZERO)));
 }
 exports.hasAuctionPrice = hasAuctionPrice;
 function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
-    return ((auction_1.isAuctionComplete(order, slot) &&
+    return (((0, auction_1.isAuctionComplete)(order, slot) &&
         calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).gte(market.amm.minOrderSize)) ||
         isOrderExpired(order, ts));
 }
@@ -119,19 +119,22 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData,
     }
     const limitPrice = getLimitPrice(order, oraclePriceData, slot);
     let baseAssetAmount;
-    const updatedAMM = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
+    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
     if (limitPrice !== undefined) {
         baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, limitPrice, oraclePriceData);
     }
     else {
         baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
     }
-    const maxBaseAssetAmount = amm_1.calculateMaxBaseAssetAmountFillable(updatedAMM, order.direction);
+    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, order.direction);
     return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
 }
 exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
 function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, oraclePriceData) {
-    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(amm, limitPrice, order.direction, oraclePriceData);
+    const adjustedLimitPrice = (0, types_1.isVariant)(order.direction, 'long')
+        ? limitPrice.sub(amm.orderTickSize)
+        : limitPrice.add(amm.orderTickSize);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, adjustedLimitPrice, order.direction, oraclePriceData);
     const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, amm.orderStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
@@ -145,12 +148,12 @@ function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, or
 }
 exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
 function isSameDirection(firstDirection, secondDirection) {
-    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
-        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
+    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
+        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function isOrderExpired(order, ts) {
     if (mustBeTriggered(order) ||
-        !types_1.isVariant(order.status, 'open') ||
+        !(0, types_1.isVariant)(order.status, 'open') ||
         order.maxTs.eq(numericConstants_1.ZERO)) {
         return false;
     }
@@ -158,26 +161,26 @@ function isOrderExpired(order, ts) {
 }
 exports.isOrderExpired = isOrderExpired;
 function isMarketOrder(order) {
-    return types_1.isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle']);
+    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle']);
 }
 exports.isMarketOrder = isMarketOrder;
 function isLimitOrder(order) {
-    return types_1.isOneOfVariant(order.orderType, ['limit', 'triggerLimit']);
+    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
 }
 exports.isLimitOrder = isLimitOrder;
 function mustBeTriggered(order) {
-    return types_1.isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']);
+    return (0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']);
 }
 exports.mustBeTriggered = mustBeTriggered;
 function isTriggered(order) {
-    return types_1.isOneOfVariant(order.triggerCondition, [
+    return (0, types_1.isOneOfVariant)(order.triggerCondition, [
         'triggeredAbove',
         'triggeredBelow',
     ]);
 }
 exports.isTriggered = isTriggered;
 function isRestingLimitOrder(order, slot) {
-    return (isLimitOrder(order) && (order.postOnly || auction_1.isAuctionComplete(order, slot)));
+    return (isLimitOrder(order) && (order.postOnly || (0, auction_1.isAuctionComplete)(order, slot)));
 }
 exports.isRestingLimitOrder = isRestingLimitOrder;
 function isTakingOrder(order, slot) {

package/lib/math/position.js

@@ -23,7 +23,7 @@ function calculateBaseAssetValue(market, userPosition, oraclePriceData, useSprea
     let prepegAmm;
     if (!skipUpdate) {
         if (market.amm.baseSpread > 0 && useSpread) {
-            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, directionToClose, oraclePriceData);
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
             prepegAmm = {
                 baseAssetReserve,
                 quoteAssetReserve,
@@ -32,13 +32,13 @@ function calculateBaseAssetValue(market, userPosition, oraclePriceData, useSprea
             };
         }
         else {
-            prepegAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
+            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
         }
     }
     else {
         prepegAmm = market.amm;
     }
-    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), amm_1.getSwapDirection('base', directionToClose));
+    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
     switch (directionToClose) {
         case types_1.PositionDirection.SHORT:
             return prepegAmm.quoteAssetReserve
@@ -67,7 +67,7 @@ function calculatePositionPNL(market, perpPosition, withFunding = false, oracleP
     if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return perpPosition.quoteAssetAmount;
     }
-    const baseAssetValue = margin_1.calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData);
+    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
     const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
         ? new __1.BN(-1)
         : new __1.BN(1);
@@ -86,7 +86,7 @@ function calculateClaimablePnl(market, spotMarket, perpPosition, oraclePriceData
     const fundingPnL = calculatePositionFundingPNL(market, perpPosition);
     let unsettledPnl = unrealizedPnl.add(fundingPnL);
     if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
-        const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, market_1.calculateNetUserPnlImbalance(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
+        const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, (0, market_1.calculateNetUserPnlImbalance)(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
         const maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount.sub(perpPosition.quoteEntryAmount), numericConstants_1.ZERO).add(excessPnlPool);
         unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
     }

package/lib/math/repeg.js

@@ -77,7 +77,7 @@ function calculateRepegCost(amm, newPeg) {
 }
 exports.calculateRepegCost = calculateRepegCost;
 function calculateBudgetedKBN(x, y, budget, Q, d) {
-    assert_1.assert(Q.gt(new anchor_1.BN(0)));
+    (0, 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))) {

package/lib/math/spotBalance.js

@@ -9,11 +9,11 @@ const numericConstants_2 = require("../constants/numericConstants");
 const utils_1 = require("./utils");
 function getBalance(tokenAmount, spotMarket, balanceType) {
     const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
-    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
     let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
-    if (!balance.eq(numericConstants_1.ZERO) && types_1.isVariant(balanceType, 'borrow')) {
+    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
         balance = balance.add(numericConstants_1.ONE);
     }
     return balance;
@@ -21,18 +21,18 @@ function getBalance(tokenAmount, spotMarket, balanceType) {
 exports.getBalance = getBalance;
 function getTokenAmount(balanceAmount, spotMarket, balanceType) {
     const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
-    if (types_1.isVariant(balanceType, 'deposit')) {
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
         return balanceAmount
             .mul(spotMarket.cumulativeDepositInterest)
             .div(precisionDecrease);
     }
     else {
-        return utils_1.divCeil(balanceAmount.mul(spotMarket.cumulativeBorrowInterest), precisionDecrease);
+        return (0, utils_1.divCeil)(balanceAmount.mul(spotMarket.cumulativeBorrowInterest), precisionDecrease);
     }
 }
 exports.getTokenAmount = getTokenAmount;
 function getSignedTokenAmount(tokenAmount, balanceType) {
-    if (types_1.isVariant(balanceType, 'deposit')) {
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
         return tokenAmount;
     }
     else {
@@ -77,10 +77,10 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = margin_1.calculateSizeDiscountAssetWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
             break;
         case 'Maintenance':
-            assetWeight = margin_1.calculateSizeDiscountAssetWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceAssetWeight));
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceAssetWeight));
             break;
         default:
             assetWeight = new anchor_1.BN(spotMarket.initialAssetWeight);
@@ -103,10 +103,10 @@ function calculateLiabilityWeight(size, spotMarket, marginCategory) {
     let liabilityWeight;
     switch (marginCategory) {
         case 'Initial':
-            liabilityWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            liabilityWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         case 'Maintenance':
-            liabilityWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            liabilityWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
             liabilityWeight = spotMarket.initialLiabilityWeight;

package/lib/math/spotMarket.js

@@ -10,12 +10,12 @@ function castNumberToSpotPrecision(value, spotMarket) {
 }
 exports.castNumberToSpotPrecision = castNumberToSpotPrecision;
 function calculateSpotMarketMarginRatio(market, marginCategory, size, balanceType) {
-    if (types_1.isVariant(balanceType, 'deposit')) {
-        const assetWeight = spotBalance_1.calculateAssetWeight(size, market, marginCategory);
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        const assetWeight = (0, spotBalance_1.calculateAssetWeight)(size, market, marginCategory);
         return numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
     }
     else {
-        const liabilityWeight = spotBalance_1.calculateLiabilityWeight(size, market, marginCategory);
+        const liabilityWeight = (0, spotBalance_1.calculateLiabilityWeight)(size, market, marginCategory);
         return liabilityWeight.sub(numericConstants_1.MARGIN_PRECISION).toNumber();
     }
 }

package/lib/math/spotPosition.js

@@ -8,15 +8,15 @@ function isSpotPositionAvailable(position) {
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
 function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
-    const tokenAmount = spotBalance_1.getSignedTokenAmount(spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
     const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
     if (tokenAmountAllBidsFill.abs().gt(tokenAmountAllAsksFill.abs())) {
-        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
     }
     else {
-        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
     }
 }

package/lib/math/trade.d.ts

@@ -6,7 +6,7 @@ import { OraclePriceData } from '../oracles/types';
 import { DLOB } from '../dlob/DLOB';
 import { PublicKey } from '@solana/web3.js';
 import { Orderbook } from '@project-serum/serum';
-export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
+export type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
  *