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

package/lib/math/trade.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateEstimatedPerpEntryPrice = exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
+exports.calculateEstimatedSpotEntryPrice = exports.calculateEstimatedPerpEntryPrice = 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");
@@ -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() +
@@ -258,39 +258,59 @@ exports.calculateTargetPriceTrade = calculateTargetPriceTrade;
  * @param oraclePriceData
  * @param dlob
  * @param slot
- * @param minPerpAuctionDuration
+ * @param usersToSkip
  */
-function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market, oraclePriceData, dlob, slot, minPerpAuctionDuration) {
+function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market, oraclePriceData, dlob, slot, usersToSkip = new Map()) {
     if (amount.eq(numericConstants_1.ZERO)) {
-        return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        return {
+            entryPrice: numericConstants_1.ZERO,
+            priceImpact: numericConstants_1.ZERO,
+            bestPrice: numericConstants_1.ZERO,
+            worstPrice: numericConstants_1.ZERO,
+            baseFilled: numericConstants_1.ZERO,
+            quoteFilled: numericConstants_1.ZERO,
+        };
     }
-    const takerIsLong = (0, 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 takerIsLong = types_2.isVariant(direction, 'long');
+    const limitOrders = dlob[takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, takerIsLong
+        ? market_1.calculateBidPrice(market, oraclePriceData)
+        : market_1.calculateAskPrice(market, oraclePriceData));
+    const swapDirection = amm_1.getSwapDirection(assetType, direction);
+    const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
     const amm = {
         baseAssetReserve,
         quoteAssetReserve,
         sqrtK: sqrtK,
         pegMultiplier: newPeg,
     };
+    const [ammBids, ammAsks] = amm_1.calculateMarketOpenBidAsk(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
+    let ammLiquidity;
+    if (assetType === 'base') {
+        ammLiquidity = takerIsLong ? ammAsks.abs() : ammBids;
+    }
+    else {
+        const [afterSwapQuoteReserves, _] = amm_1.calculateAmmReservesAfterSwap(amm, 'base', takerIsLong ? ammAsks.abs() : ammBids, amm_1.getSwapDirection('base', direction));
+        ammLiquidity = amm_1.calculateQuoteAssetAmountSwapped(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
+    }
     const invariant = amm.sqrtK.mul(amm.sqrtK);
-    let initialPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    let bestPrice = amm_1.calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
     let cumulativeBaseFilled = numericConstants_1.ZERO;
     let cumulativeQuoteFilled = numericConstants_1.ZERO;
     let limitOrder = limitOrders.next().value;
     if (limitOrder) {
         const limitOrderPrice = limitOrder.getPrice(oraclePriceData, slot);
-        initialPrice = takerIsLong
-            ? anchor_1.BN.min(limitOrderPrice, initialPrice)
-            : anchor_1.BN.max(limitOrderPrice, initialPrice);
+        bestPrice = takerIsLong
+            ? anchor_1.BN.min(limitOrderPrice, bestPrice)
+            : anchor_1.BN.max(limitOrderPrice, bestPrice);
     }
+    let worstPrice = bestPrice;
     if (assetType === 'base') {
-        while (!cumulativeBaseFilled.eq(amount)) {
+        while (!cumulativeBaseFilled.eq(amount) &&
+            (ammLiquidity.gt(numericConstants_1.ZERO) || limitOrder)) {
             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)
@@ -303,22 +323,29 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             else {
                 maxAmmFill = amount.sub(cumulativeBaseFilled);
             }
+            maxAmmFill = anchor_1.BN.min(maxAmmFill, ammLiquidity);
             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);
+                ammLiquidity = ammLiquidity.sub(baseFilled);
+                const quoteFilled = amm_1.calculateQuoteAssetAmountSwapped(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
                 cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
                 cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
                 amm.baseAssetReserve = afterSwapBaseReserves;
                 amm.quoteAssetReserve = afterSwapQuoteReserves;
+                worstPrice = amm_1.calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
                 if (cumulativeBaseFilled.eq(amount)) {
                     break;
                 }
             }
+            if (limitOrder && usersToSkip.has(limitOrder.userAccount)) {
+                continue;
+            }
             const baseFilled = anchor_1.BN.min(limitOrder.order.baseAssetAmount.sub(limitOrder.order.baseAssetAmountFilled), amount.sub(cumulativeBaseFilled));
             const quoteFilled = baseFilled.mul(limitOrderPrice).div(numericConstants_1.BASE_PRECISION);
             cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
             cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            worstPrice = limitOrderPrice;
             if (cumulativeBaseFilled.eq(amount)) {
                 break;
             }
@@ -326,11 +353,12 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
         }
     }
     else {
-        while (!cumulativeQuoteFilled.eq(amount)) {
+        while (!cumulativeQuoteFilled.eq(amount) &&
+            (ammLiquidity.gt(numericConstants_1.ZERO) || limitOrder)) {
             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)
@@ -343,9 +371,11 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             else {
                 maxAmmFill = amount.sub(cumulativeQuoteFilled);
             }
+            maxAmmFill = anchor_1.BN.min(maxAmmFill, ammLiquidity);
             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);
+                ammLiquidity = ammLiquidity.sub(quoteFilled);
                 const baseFilled = afterSwapBaseReserves
                     .sub(amm.baseAssetReserve)
                     .abs();
@@ -353,10 +383,14 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
                 cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
                 amm.baseAssetReserve = afterSwapBaseReserves;
                 amm.quoteAssetReserve = afterSwapQuoteReserves;
+                worstPrice = amm_1.calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
                 if (cumulativeQuoteFilled.eq(amount)) {
                     break;
                 }
             }
+            if (limitOrder && usersToSkip.has(limitOrder.userAccount)) {
+                continue;
+            }
             const quoteFilled = anchor_1.BN.min(limitOrder.order.baseAssetAmount
                 .sub(limitOrder.order.baseAssetAmountFilled)
                 .mul(limitOrderPrice)
@@ -364,6 +398,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
             const baseFilled = quoteFilled.mul(numericConstants_1.BASE_PRECISION).div(limitOrderPrice);
             cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
             cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            worstPrice = limitOrderPrice;
             if (cumulativeQuoteFilled.eq(amount)) {
                 break;
             }
@@ -374,10 +409,153 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
         .mul(numericConstants_1.BASE_PRECISION)
         .div(cumulativeBaseFilled);
     const priceImpact = entryPrice
-        .sub(initialPrice)
+        .sub(bestPrice)
         .mul(numericConstants_1.PRICE_PRECISION)
-        .div(initialPrice)
+        .div(bestPrice)
         .abs();
-    return [entryPrice, priceImpact];
+    return {
+        entryPrice,
+        priceImpact,
+        bestPrice,
+        worstPrice,
+        baseFilled: cumulativeBaseFilled,
+        quoteFilled: cumulativeQuoteFilled,
+    };
 }
 exports.calculateEstimatedPerpEntryPrice = calculateEstimatedPerpEntryPrice;
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or serum)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param serumBids
+ * @param serumAsks
+ * @param slot
+ * @param usersToSkip
+ */
+function calculateEstimatedSpotEntryPrice(assetType, amount, direction, market, oraclePriceData, dlob, serumBids, serumAsks, slot, usersToSkip = new Map()) {
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return {
+            entryPrice: numericConstants_1.ZERO,
+            priceImpact: numericConstants_1.ZERO,
+            bestPrice: numericConstants_1.ZERO,
+            worstPrice: numericConstants_1.ZERO,
+            baseFilled: numericConstants_1.ZERO,
+            quoteFilled: numericConstants_1.ZERO,
+        };
+    }
+    const basePrecision = new anchor_1.BN(Math.pow(10, market.decimals));
+    const takerIsLong = types_2.isVariant(direction, 'long');
+    const dlobLimitOrders = dlob[takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'](market.marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
+    const serumLimitOrders = takerIsLong
+        ? serumAsks.getL2(100)
+        : serumBids.getL2(100);
+    let cumulativeBaseFilled = numericConstants_1.ZERO;
+    let cumulativeQuoteFilled = numericConstants_1.ZERO;
+    let dlobLimitOrder = dlobLimitOrders.next().value;
+    let serumLimitOrder = serumLimitOrders.shift();
+    const dlobLimitOrderPrice = dlobLimitOrder === null || dlobLimitOrder === void 0 ? void 0 : dlobLimitOrder.getPrice(oraclePriceData, slot);
+    const serumLimitOrderPrice = serumLimitOrder
+        ? new anchor_1.BN(serumLimitOrder[0] * numericConstants_1.PRICE_PRECISION.toNumber())
+        : undefined;
+    const bestPrice = takerIsLong
+        ? anchor_1.BN.min(serumLimitOrderPrice || numericConstants_1.BN_MAX, dlobLimitOrderPrice || numericConstants_1.BN_MAX)
+        : anchor_1.BN.max(serumLimitOrderPrice || numericConstants_1.ZERO, dlobLimitOrderPrice || numericConstants_1.ZERO);
+    let worstPrice = bestPrice;
+    if (assetType === 'base') {
+        while (!cumulativeBaseFilled.eq(amount) &&
+            (dlobLimitOrder || serumLimitOrder)) {
+            const dlobLimitOrderPrice = dlobLimitOrder === null || dlobLimitOrder === void 0 ? void 0 : dlobLimitOrder.getPrice(oraclePriceData, slot);
+            const serumLimitOrderPrice = serumLimitOrder
+                ? new anchor_1.BN(serumLimitOrder[0] * numericConstants_1.PRICE_PRECISION.toNumber())
+                : undefined;
+            const useSerum = takerIsLong
+                ? (serumLimitOrderPrice || numericConstants_1.BN_MAX).lt(dlobLimitOrderPrice || numericConstants_1.BN_MAX)
+                : (serumLimitOrderPrice || numericConstants_1.ZERO).gt(dlobLimitOrderPrice || numericConstants_1.ZERO);
+            if (!useSerum) {
+                if (dlobLimitOrder && usersToSkip.has(dlobLimitOrder.userAccount)) {
+                    continue;
+                }
+                const baseFilled = anchor_1.BN.min(dlobLimitOrder.order.baseAssetAmount.sub(dlobLimitOrder.order.baseAssetAmountFilled), amount.sub(cumulativeBaseFilled));
+                const quoteFilled = baseFilled
+                    .mul(dlobLimitOrderPrice)
+                    .div(basePrecision);
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                worstPrice = dlobLimitOrder;
+                dlobLimitOrder = dlobLimitOrders.next().value;
+            }
+            else {
+                const baseFilled = anchor_1.BN.min(new anchor_1.BN(serumLimitOrder[1] * basePrecision.toNumber()), amount.sub(cumulativeBaseFilled));
+                const quoteFilled = baseFilled
+                    .mul(serumLimitOrderPrice)
+                    .div(basePrecision);
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                worstPrice = serumLimitOrderPrice;
+                serumLimitOrder = serumLimitOrders.shift();
+            }
+        }
+    }
+    else {
+        while (!cumulativeQuoteFilled.eq(amount) &&
+            (dlobLimitOrder || serumLimitOrder)) {
+            const dlobLimitOrderPrice = dlobLimitOrder === null || dlobLimitOrder === void 0 ? void 0 : dlobLimitOrder.getPrice(oraclePriceData, slot);
+            const serumLimitOrderPrice = serumLimitOrder
+                ? new anchor_1.BN(serumLimitOrder[0] * numericConstants_1.PRICE_PRECISION.toNumber())
+                : undefined;
+            const useSerum = takerIsLong
+                ? (serumLimitOrderPrice || numericConstants_1.BN_MAX).lt(dlobLimitOrderPrice || numericConstants_1.BN_MAX)
+                : (serumLimitOrderPrice || numericConstants_1.ZERO).gt(dlobLimitOrderPrice || numericConstants_1.ZERO);
+            if (!useSerum) {
+                if (dlobLimitOrder && usersToSkip.has(dlobLimitOrder.userAccount)) {
+                    continue;
+                }
+                const quoteFilled = anchor_1.BN.min(dlobLimitOrder.order.baseAssetAmount
+                    .sub(dlobLimitOrder.order.baseAssetAmountFilled)
+                    .mul(dlobLimitOrderPrice)
+                    .div(basePrecision), amount.sub(cumulativeQuoteFilled));
+                const baseFilled = quoteFilled
+                    .mul(basePrecision)
+                    .div(dlobLimitOrderPrice);
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                worstPrice = dlobLimitOrderPrice;
+                dlobLimitOrder = dlobLimitOrders.next().value;
+            }
+            else {
+                const serumOrderBaseAmount = new anchor_1.BN(serumLimitOrder[1] * basePrecision.toNumber());
+                const quoteFilled = anchor_1.BN.min(serumOrderBaseAmount.mul(serumLimitOrderPrice).div(basePrecision), amount.sub(cumulativeQuoteFilled));
+                const baseFilled = quoteFilled
+                    .mul(basePrecision)
+                    .div(serumLimitOrderPrice);
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                worstPrice = serumLimitOrderPrice;
+                serumLimitOrder = serumLimitOrders.shift();
+            }
+        }
+    }
+    const entryPrice = cumulativeQuoteFilled
+        .mul(basePrecision)
+        .div(cumulativeBaseFilled);
+    const priceImpact = entryPrice
+        .sub(bestPrice)
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(bestPrice)
+        .abs();
+    return {
+        entryPrice,
+        priceImpact,
+        bestPrice,
+        worstPrice,
+        baseFilled: cumulativeBaseFilled,
+        quoteFilled: cumulativeQuoteFilled,
+    };
+}
+exports.calculateEstimatedSpotEntryPrice = calculateEstimatedSpotEntryPrice;

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[]>;