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

package/lib/dlob/DLOB.d.ts

@@ -56,7 +56,7 @@ export declare class DLOB {
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
     findLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     findMarketNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
-    findMarketNodesCrossingLimitNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
+    findMarketNodesCrossingLimitNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackPrice?: BN) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean, fallbackPrice?: BN): NodeToFill[];
     findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, fallbackPrice: BN, doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean): NodeToFill[];
     findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
     findJitAuctionNodesToFill(marketIndex: number, slot: number, marketType: MarketType): NodeToFill[];
@@ -65,21 +65,21 @@ export declare class DLOB {
     private getBestNode;
     getLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     /**
-     * Filters the limit asks that are post only or have been place for sufficiently long
-     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     * Filters the limit asks that are post only, have been place for sufficiently long or are above the fallback bid
+     * Market orders can only fill against orders that meet this criteria
      *
      * @returns
      */
-    getRestingLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, minPerpAuctionDuration: number): Generator<DLOBNode>;
-    isRestingLimitOrder(order: Order, slot: number, minPerpAuctionDuration: number): boolean;
+    getMakerLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackBid?: BN): Generator<DLOBNode>;
+    isRestingLimitOrder(order: Order, slot: number): boolean;
     getLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     /**
-     * Filters the limit bids that are post only or have been place for sufficiently long
-     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     * Filters the limit bids that are post only, have been place for sufficiently long or are below the fallback ask
+     * Market orders can only fill against orders that meet this criteria
      *
      * @returns
      */
-    getRestingLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, minPerpAuctionDuration: number): Generator<DLOBNode>;
+    getMakerLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackAsk?: BN): Generator<DLOBNode>;
     getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getBids(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];

package/lib/dlob/DLOB.js

@@ -288,9 +288,9 @@ class DLOB {
     findMarketNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
-        const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getLimitBids.bind(this), (takerPrice, makerPrice) => {
+        const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitBids.bind(this), (takerPrice, makerPrice) => {
             return takerPrice === undefined || takerPrice.lte(makerPrice);
-        });
+        }, fallbackAsk);
         for (const marketAskCrossingBid of marketAsksCrossingBids) {
             nodesToFill.push(marketAskCrossingBid);
         }
@@ -304,9 +304,9 @@ class DLOB {
             }
         }
         marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
-        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getLimitAsks.bind(this), (takerPrice, fallbackPrice) => {
+        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitAsks.bind(this), (takerPrice, fallbackPrice) => {
             return takerPrice === undefined || takerPrice.gte(fallbackPrice);
-        });
+        }, fallbackBid);
         for (const marketBidToFill of marketBidsToFill) {
             nodesToFill.push(marketBidToFill);
         }
@@ -321,10 +321,10 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, takerNodeGenerator, makerNodeGeneratorFn, doesCross) {
+    findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, takerNodeGenerator, makerNodeGeneratorFn, doesCross, fallbackPrice) {
         const nodesToFill = new Array();
         for (const takerNode of takerNodeGenerator) {
-            const makerNodeGenerator = makerNodeGeneratorFn(marketIndex, slot, marketType, oraclePriceData);
+            const makerNodeGenerator = makerNodeGeneratorFn(marketIndex, slot, marketType, oraclePriceData, fallbackPrice);
             for (const makerNode of makerNodeGenerator) {
                 // Can't match orders from the same user
                 const sameUser = takerNode.userAccount.equals(makerNode.userAccount);
@@ -536,21 +536,24 @@ class DLOB {
         });
     }
     /**
-     * Filters the limit asks that are post only or have been place for sufficiently long
-     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     * Filters the limit asks that are post only, have been place for sufficiently long or are above the fallback bid
+     * Market orders can only fill against orders that meet this criteria
      *
      * @returns
      */
-    *getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData, minPerpAuctionDuration) {
+    *getMakerLimitAsks(marketIndex, slot, marketType, oraclePriceData, fallbackBid) {
         for (const node of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
-            if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+            if (this.isRestingLimitOrder(node.order, slot)) {
+                yield node;
+            }
+            else if (fallbackBid &&
+                node.getPrice(oraclePriceData, slot).gt(fallbackBid)) {
                 yield node;
             }
         }
     }
-    isRestingLimitOrder(order, slot, minPerpAuctionDuration) {
-        return (order.postOnly ||
-            new __1.BN(slot).sub(order.slot).gte(new __1.BN(minPerpAuctionDuration * 1.5)));
+    isRestingLimitOrder(order, slot) {
+        return order.postOnly || new __1.BN(slot).sub(order.slot).gte(new __1.BN(15));
     }
     *getLimitBids(marketIndex, slot, marketType, oraclePriceData) {
         if (__1.isVariant(marketType, 'spot') && !oraclePriceData) {
@@ -570,14 +573,18 @@ class DLOB {
         });
     }
     /**
-     * Filters the limit bids that are post only or have been place for sufficiently long
-     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     * Filters the limit bids that are post only, have been place for sufficiently long or are below the fallback ask
+     * Market orders can only fill against orders that meet this criteria
      *
      * @returns
      */
-    *getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData, minPerpAuctionDuration) {
+    *getMakerLimitBids(marketIndex, slot, marketType, oraclePriceData, fallbackAsk) {
         for (const node of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
-            if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+            if (this.isRestingLimitOrder(node.order, slot)) {
+                yield node;
+            }
+            else if (fallbackAsk &&
+                node.getPrice(oraclePriceData, slot).lt(fallbackAsk)) {
                 yield node;
             }
         }

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.12.0-beta.3",
+    "version": "2.12.0",
     "name": "drift",
     "instructions": [
         {

package/lib/math/trade.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="bn.js" />
-import { PerpMarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection, SpotMarketAccount } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 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';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
@@ -64,6 +66,36 @@ export declare function calculateTargetPriceTrade(market: PerpMarketAccount, tar
  * @param oraclePriceData
  * @param dlob
  * @param slot
- * @param minPerpAuctionDuration
+ * @param usersToSkip
  */
-export declare function calculateEstimatedPerpEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number, minPerpAuctionDuration: number): [BN, BN];
+export declare function calculateEstimatedPerpEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number, usersToSkip?: Map<PublicKey, boolean>): {
+    entryPrice: BN;
+    priceImpact: BN;
+    bestPrice: BN;
+    worstPrice: BN;
+    baseFilled: BN;
+    quoteFilled: BN;
+};
+/**
+ * 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
+ */
+export declare function calculateEstimatedSpotEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: SpotMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, serumBids: Orderbook, serumAsks: Orderbook, slot: number, usersToSkip?: Map<PublicKey, boolean>): {
+    entryPrice: BN;
+    priceImpact: BN;
+    bestPrice: BN;
+    worstPrice: BN;
+    baseFilled: BN;
+    quoteFilled: BN;
+};

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");
@@ -258,14 +258,23 @@ 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 = types_2.isVariant(direction, 'long');
-    const limitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, minPerpAuctionDuration);
+    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 = {
@@ -274,19 +283,30 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
         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 = 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) {
@@ -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] = 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,7 +353,8 @@ 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) {
@@ -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] = 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.12.0-beta.3",
+	"version": "2.12.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/dlob/DLOB.ts

@@ -519,10 +519,11 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			marketOrderGenerator,
-			this.getLimitBids.bind(this),
+			this.getMakerLimitBids.bind(this),
 			(takerPrice, makerPrice) => {
 				return takerPrice === undefined || takerPrice.lte(makerPrice);
-			}
+			},
+			fallbackAsk
 		);
 		for (const marketAskCrossingBid of marketAsksCrossingBids) {
 			nodesToFill.push(marketAskCrossingBid);
@@ -555,10 +556,11 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			marketOrderGenerator,
-			this.getLimitAsks.bind(this),
+			this.getMakerLimitAsks.bind(this),
 			(takerPrice, fallbackPrice) => {
 				return takerPrice === undefined || takerPrice.gte(fallbackPrice);
-			}
+			},
+			fallbackBid
 		);
 
 		for (const marketBidToFill of marketBidsToFill) {
@@ -596,9 +598,11 @@ export class DLOB {
 			marketIndex: number,
 			slot: number,
 			marketType: MarketType,
-			oraclePriceData: OraclePriceData
+			oraclePriceData: OraclePriceData,
+			fallbackPrice?: BN
 		) => Generator<DLOBNode>,
-		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean
+		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean,
+		fallbackPrice?: BN
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -607,7 +611,8 @@ export class DLOB {
 				marketIndex,
 				slot,
 				marketType,
-				oraclePriceData
+				oraclePriceData,
+				fallbackPrice
 			);
 
 			for (const makerNode of makerNodeGenerator) {
@@ -916,17 +921,17 @@ export class DLOB {
 	}
 
 	/**
-	 * Filters the limit asks that are post only or have been place for sufficiently long
-	 * Useful for displaying order book that doesn't have taker limit orders crossing spread
+	 * Filters the limit asks that are post only, have been place for sufficiently long or are above the fallback bid
+	 * Market orders can only fill against orders that meet this criteria
 	 *
 	 * @returns
 	 */
-	*getRestingLimitAsks(
+	*getMakerLimitAsks(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
-		minPerpAuctionDuration: number
+		fallbackBid?: BN
 	): Generator<DLOBNode> {
 		for (const node of this.getLimitAsks(
 			marketIndex,
@@ -934,21 +939,19 @@ export class DLOB {
 			marketType,
 			oraclePriceData
 		)) {
-			if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+			if (this.isRestingLimitOrder(node.order, slot)) {
+				yield node;
+			} else if (
+				fallbackBid &&
+				node.getPrice(oraclePriceData, slot).gt(fallbackBid)
+			) {
 				yield node;
 			}
 		}
 	}
 
-	isRestingLimitOrder(
-		order: Order,
-		slot: number,
-		minPerpAuctionDuration: number
-	): boolean {
-		return (
-			order.postOnly ||
-			new BN(slot).sub(order.slot).gte(new BN(minPerpAuctionDuration * 1.5))
-		);
+	isRestingLimitOrder(order: Order, slot: number): boolean {
+		return order.postOnly || new BN(slot).sub(order.slot).gte(new BN(15));
 	}
 
 	*getLimitBids(
@@ -984,17 +987,17 @@ export class DLOB {
 	}
 
 	/**
-	 * Filters the limit bids that are post only or have been place for sufficiently long
-	 * Useful for displaying order book that doesn't have taker limit orders crossing spread
+	 * Filters the limit bids that are post only, have been place for sufficiently long or are below the fallback ask
+	 * Market orders can only fill against orders that meet this criteria
 	 *
 	 * @returns
 	 */
-	*getRestingLimitBids(
+	*getMakerLimitBids(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
-		minPerpAuctionDuration: number
+		fallbackAsk?: BN
 	): Generator<DLOBNode> {
 		for (const node of this.getLimitBids(
 			marketIndex,
@@ -1002,7 +1005,12 @@ export class DLOB {
 			marketType,
 			oraclePriceData
 		)) {
-			if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+			if (this.isRestingLimitOrder(node.order, slot)) {
+				yield node;
+			} else if (
+				fallbackAsk &&
+				node.getPrice(oraclePriceData, slot).lt(fallbackAsk)
+			) {
 				yield node;
 			}
 		}

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.12.0-beta.3",
+  "version": "2.12.0",
   "name": "drift",
   "instructions": [
     {