@drift-labs/sdk 2.12.0-beta.2 → 2.12.0-beta.3

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 ((0, types_1.isVariant)(order.status, 'init')) {
+    if (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) && (0, types_1.isVariant)(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
         return true;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        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 ((0, types_1.isVariant)(order.status, 'init')) {
+    if (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) && (0, types_1.isVariant)(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
         return true;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        types_1.isVariant(order.direction, 'short')) {
         return true;
     }
     return false;
 }
 exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
 function isOrderReduceOnly(user, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
+    if (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) &&
-        (0, types_1.isVariant)(order.direction, 'long')) {
+        types_1.isVariant(order.direction, 'long')) {
         return false;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        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 = (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
+        limitPrice = auction_1.getAuctionPrice(order, slot, oraclePriceData.price);
     }
     else if (order.oraclePriceOffset !== 0) {
         limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
@@ -99,15 +99,15 @@ exports.getLimitPrice = getLimitPrice;
 function hasLimitPrice(order, slot) {
     return (order.price.gt(numericConstants_1.ZERO) ||
         order.oraclePriceOffset != 0 ||
-        !(0, auction_1.isAuctionComplete)(order, slot));
+        !auction_1.isAuctionComplete(order, slot));
 }
 exports.hasLimitPrice = hasLimitPrice;
 function hasAuctionPrice(order, slot) {
-    return isMarketOrder(order) && !(0, auction_1.isAuctionComplete)(order, slot);
+    return isMarketOrder(order) && !auction_1.isAuctionComplete(order, slot);
 }
 exports.hasAuctionPrice = hasAuctionPrice;
 function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
-    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+    return ((auction_1.isAuctionComplete(order, slot) &&
         !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
         isOrderExpired(order, ts));
 }
@@ -118,19 +118,19 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData,
     }
     const limitPrice = getLimitPrice(order, oraclePriceData, slot);
     let baseAssetAmount;
-    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    const updatedAMM = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
     if (limitPrice !== undefined) {
         baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, limitPrice, oraclePriceData);
     }
     else {
         baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
     }
-    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, order.direction);
+    const maxBaseAssetAmount = 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] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, limitPrice, order.direction, oraclePriceData);
+    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(amm, limitPrice, order.direction, oraclePriceData);
     const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, amm.orderStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
@@ -144,12 +144,12 @@ function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, or
 }
 exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
 function isSameDirection(firstDirection, secondDirection) {
-    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')));
+    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
+        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
 }
 function isOrderExpired(order, ts) {
     if (mustBeTriggered(order) ||
-        !(0, types_1.isVariant)(order.status, 'open') ||
+        !types_1.isVariant(order.status, 'open') ||
         order.maxTs.eq(numericConstants_1.ZERO)) {
         return false;
     }
@@ -157,19 +157,19 @@ function isOrderExpired(order, ts) {
 }
 exports.isOrderExpired = isOrderExpired;
 function isMarketOrder(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle']);
+    return types_1.isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle']);
 }
 exports.isMarketOrder = isMarketOrder;
 function isLimitOrder(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
+    return types_1.isOneOfVariant(order.orderType, ['limit', 'triggerLimit']);
 }
 exports.isLimitOrder = isLimitOrder;
 function mustBeTriggered(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']);
+    return types_1.isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']);
 }
 exports.mustBeTriggered = mustBeTriggered;
 function isTriggered(order) {
-    return (0, types_1.isOneOfVariant)(order.triggerCondition, [
+    return types_1.isOneOfVariant(order.triggerCondition, [
         'triggeredAbove',
         'triggeredBelow',
     ]);

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 } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, directionToClose, oraclePriceData);
             prepegAmm = {
                 baseAssetReserve,
                 quoteAssetReserve,
@@ -32,13 +32,13 @@ function calculateBaseAssetValue(market, userPosition, oraclePriceData, useSprea
             };
         }
         else {
-            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+            prepegAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
         }
     }
     else {
         prepegAmm = market.amm;
     }
-    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
+    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), 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 = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    const baseAssetValue = 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, (0, market_1.calculateNetUserPnlImbalance)(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
+        const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, 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) {
-    (0, assert_1.assert)(Q.gt(new anchor_1.BN(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

@@ -8,11 +8,11 @@ const margin_1 = require("./margin");
 const numericConstants_2 = require("../constants/numericConstants");
 function getBalance(tokenAmount, spotMarket, balanceType) {
     const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
-    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
     let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
-    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
+    if (!balance.eq(numericConstants_1.ZERO) && types_1.isVariant(balanceType, 'borrow')) {
         balance = balance.add(numericConstants_1.ONE);
     }
     return balance;
@@ -20,14 +20,14 @@ 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));
-    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
     return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 exports.getTokenAmount = getTokenAmount;
 function getSignedTokenAmount(tokenAmount, balanceType) {
-    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+    if (types_1.isVariant(balanceType, 'deposit')) {
         return tokenAmount;
     }
     else {
@@ -57,7 +57,7 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
+            assetWeight = margin_1.calculateSizeDiscountAssetWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
             break;
         case 'Maintenance':
             assetWeight = new anchor_1.BN(spotMarket.maintenanceAssetWeight);
@@ -83,10 +83,10 @@ function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            assetWeight = 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':
-            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
             assetWeight = spotMarket.initialLiabilityWeight;

package/lib/math/spotPosition.js

@@ -8,15 +8,15 @@ function isSpotPositionAvailable(position) {
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
 function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
-    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenAmount = spotBalance_1.getSignedTokenAmount(spotBalance_1.getTokenAmount(spotPosition.scaledBalance, 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 = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
     }
     else {
-        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
     }
 }

package/lib/math/trade.js

@@ -30,15 +30,15 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
 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.calculateReservePrice)(market, oraclePriceData);
+        oldPrice = market_1.calculateReservePrice(market, oraclePriceData);
     }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
@@ -50,7 +50,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
         .div(acquiredBaseReserve.abs());
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
         amm = {
             baseAssetReserve,
             quoteAssetReserve,
@@ -61,12 +61,12 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     else {
         amm = market.amm;
     }
-    const 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));
     }
     const pctMaxSlippage = newPrice
         .sub(oldPrice)
@@ -96,10 +96,10 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
-    const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
+    const swapDirection = amm_1.getSwapDirection(inputAssetType, direction);
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
         amm = {
             baseAssetReserve,
             quoteAssetReserve,
@@ -110,10 +110,10 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     else {
         amm = market.amm;
     }
-    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(amm, inputAssetType, amount, swapDirection);
     const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    const acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    const acquiredQuoteAssetAmount = amm_1.calculateQuoteAssetAmountSwapped(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
     return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
@@ -135,12 +135,12 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * ]
  */
 function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', oraclePriceData, 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));
-    const reservePriceBefore = (0, market_1.calculateReservePrice)(market, oraclePriceData);
-    const bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
-    const askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+    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 reservePriceBefore = market_1.calculateReservePrice(market, oraclePriceData);
+    const bidPriceBefore = market_1.calculateBidPrice(market, oraclePriceData);
+    const askPriceBefore = market_1.calculateAskPrice(market, oraclePriceData);
     let direction;
     if (targetPrice.gt(reservePriceBefore)) {
         const priceGap = targetPrice.sub(reservePriceBefore);
@@ -160,7 +160,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     let quoteAssetReserveBefore;
     let peg = market.amm.pegMultiplier;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+        const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
         baseAssetReserveBefore = baseAssetReserve;
         quoteAssetReserveBefore = quoteAssetReserve;
         peg = newPeg;
@@ -190,9 +190,9 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     else if (reservePriceBefore.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.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)
@@ -203,9 +203,9 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     else if (reservePriceBefore.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.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)
@@ -232,8 +232,8 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.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() +
@@ -264,10 +264,10 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
-    const takerIsLong = (0, types_2.isVariant)(direction, 'long');
+    const takerIsLong = types_2.isVariant(direction, 'long');
     const limitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, minPerpAuctionDuration);
-    const swapDirection = (0, amm_1.getSwapDirection)(assetType, direction);
-    const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+    const swapDirection = amm_1.getSwapDirection(assetType, direction);
+    const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
     const amm = {
         baseAssetReserve,
         quoteAssetReserve,
@@ -275,7 +275,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
         pegMultiplier: newPeg,
     };
     const invariant = amm.sqrtK.mul(amm.sqrtK);
-    let initialPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    let initialPrice = amm_1.calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
     let cumulativeBaseFilled = numericConstants_1.ZERO;
     let cumulativeQuoteFilled = numericConstants_1.ZERO;
     let limitOrder = limitOrders.next().value;
@@ -290,7 +290,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             const limitOrderPrice = limitOrder === null || limitOrder === void 0 ? void 0 : limitOrder.getPrice(oraclePriceData, slot);
             let maxAmmFill;
             if (limitOrderPrice) {
-                const newBaseReserves = (0, utils_1.squareRootBN)(invariant
+                const newBaseReserves = utils_1.squareRootBN(invariant
                     .mul(numericConstants_1.PRICE_PRECISION)
                     .mul(amm.pegMultiplier)
                     .div(limitOrderPrice)
@@ -305,8 +305,8 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             }
             if (maxAmmFill.gt(numericConstants_1.ZERO)) {
                 const baseFilled = anchor_1.BN.min(amount.sub(cumulativeBaseFilled), maxAmmFill);
-                const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'base', baseFilled, swapDirection);
-                const quoteFilled = (0, amm_1.calculateQuoteAssetAmountSwapped)(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
+                const [afterSwapQuoteReserves, afterSwapBaseReserves] = amm_1.calculateAmmReservesAfterSwap(amm, 'base', baseFilled, swapDirection);
+                const quoteFilled = amm_1.calculateQuoteAssetAmountSwapped(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
                 cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
                 cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
                 amm.baseAssetReserve = afterSwapBaseReserves;
@@ -330,7 +330,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             const limitOrderPrice = limitOrder === null || limitOrder === void 0 ? void 0 : limitOrder.getPrice(oraclePriceData, slot);
             let maxAmmFill;
             if (limitOrderPrice) {
-                const newQuoteReserves = (0, utils_1.squareRootBN)(invariant
+                const newQuoteReserves = utils_1.squareRootBN(invariant
                     .mul(numericConstants_1.PEG_PRECISION)
                     .mul(limitOrderPrice)
                     .div(amm.pegMultiplier)
@@ -345,7 +345,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             }
             if (maxAmmFill.gt(numericConstants_1.ZERO)) {
                 const quoteFilled = anchor_1.BN.min(amount.sub(cumulativeQuoteFilled), maxAmmFill);
-                const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteFilled, swapDirection);
+                const [afterSwapQuoteReserves, afterSwapBaseReserves] = amm_1.calculateAmmReservesAfterSwap(amm, 'quote', quoteFilled, swapDirection);
                 const baseFilled = afterSwapBaseReserves
                     .sub(amm.baseAssetReserve)
                     .abs();

package/lib/oracles/oracleClientCache.js

@@ -11,7 +11,7 @@ class OracleClientCache {
         if (this.cache.has(key)) {
             return this.cache.get(key);
         }
-        const client = (0, oracleClient_1.getOracleClient)(oracleSource, connection);
+        const client = oracleClient_1.getOracleClient(oracleSource, connection);
         this.cache.set(key, client);
         return client;
     }

package/lib/oracles/pythClient.js

@@ -13,7 +13,7 @@ class PythClient {
         return this.getOraclePriceDataFromBuffer(accountInfo.data);
     }
     getOraclePriceDataFromBuffer(buffer) {
-        const priceData = (0, client_1.parsePriceData)(buffer);
+        const priceData = client_1.parsePriceData(buffer);
         return {
             price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
             slot: new anchor_1.BN(priceData.lastSlot.toString()),

package/lib/tokenFaucet.js

@@ -1,11 +1,7 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/lib/tx/retryTxSender.js

@@ -93,7 +93,7 @@ class RetryTxSender {
         catch (err) {
             throw new Error('signature must be base58 encoded: ' + signature);
         }
-        (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+        assert_1.default(decodedSignature.length === 64, 'signature has invalid length');
         const start = Date.now();
         const subscriptionCommitment = commitment || this.provider.opts.commitment;
         const subscriptionIds = new Array();

package/lib/tx/utils.d.ts

@@ -1,2 +1,2 @@
 import { Transaction, TransactionInstruction } from '@solana/web3.js';
-export declare function wrapInTx(instruction: TransactionInstruction, computeUnits?: number): Transaction;
+export declare function wrapInTx(instruction: TransactionInstruction, computeUnits?: number, computeUnitsPrice?: number): Transaction;

package/lib/tx/utils.js

@@ -3,13 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapInTx = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const COMPUTE_UNITS_DEFAULT = 200000;
-function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
-) {
+function wrapInTx(instruction, computeUnits = 600000, computeUnitsPrice = 0) {
     const tx = new web3_js_1.Transaction();
     if (computeUnits != COMPUTE_UNITS_DEFAULT) {
-        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+        tx.add(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
             units: computeUnits,
-            additionalFee: 0,
+        }));
+    }
+    if (computeUnitsPrice != 0) {
+        tx.add(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: computeUnitsPrice,
         }));
     }
     return tx.add(instruction);

package/lib/types.d.ts

@@ -923,6 +923,10 @@ export declare type ReferrerInfo = {
     referrer: PublicKey;
     referrerStats: PublicKey;
 };
+export declare type TxParams = {
+    computeUnits?: number;
+    computeUnitsPrice?: number;
+};
 export interface IWallet {
     signTransaction(tx: Transaction): Promise<Transaction>;
     signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;