@drift-labs/sdk 2.17.0 → 2.18.0-beta.1

package/lib/dlob/DLOB.js

@@ -15,6 +15,7 @@ class DLOB {
     constructor() {
         this.openOrders = new Map();
         this.orderLists = new Map();
+        this.maxSlotForRestingLimitOrders = 0;
         this.initialized = false;
         this.init();
     }
@@ -42,6 +43,7 @@ class DLOB {
             }
         }
         this.orderLists.clear();
+        this.maxSlotForRestingLimitOrders = 0;
         this.init();
     }
     /**
@@ -49,7 +51,7 @@ class DLOB {
      *
      * @returns a promise that resolves when the DLOB is initialized
      */
-    async initFromUserMap(userMap) {
+    async initFromUserMap(userMap, slot) {
         if (this.initialized) {
             return false;
         }
@@ -58,26 +60,26 @@ class DLOB {
             const userAccount = user.getUserAccount();
             const userAccountPubkey = user.getUserAccountPublicKey();
             for (const order of userAccount.orders) {
-                this.insertOrder(order, userAccountPubkey);
+                this.insertOrder(order, userAccountPubkey, slot);
             }
         }
         this.initialized = true;
         return true;
     }
-    initFromOrders(dlobOrders) {
+    initFromOrders(dlobOrders, slot) {
         if (this.initialized) {
             return false;
         }
         for (const { user, order } of dlobOrders) {
-            this.insertOrder(order, user);
+            this.insertOrder(order, user, slot);
         }
         this.initialized = true;
         return true;
     }
-    handleOrderRecord(record) {
-        this.insertOrder(record.order, record.user);
+    handleOrderRecord(record, slot) {
+        this.insertOrder(record.order, record.user, slot);
     }
-    handleOrderActionRecord(record) {
+    handleOrderActionRecord(record, slot) {
         if (__1.isOneOfVariant(record.action, ['place', 'expire'])) {
             return;
         }
@@ -85,13 +87,13 @@ class DLOB {
             if (record.taker !== null) {
                 const takerOrder = this.getOrder(record.takerOrderId, record.taker);
                 if (takerOrder) {
-                    this.trigger(takerOrder, record.taker);
+                    this.trigger(takerOrder, record.taker, slot);
                 }
             }
             if (record.maker !== null) {
                 const makerOrder = this.getOrder(record.makerOrderId, record.maker);
                 if (makerOrder) {
-                    this.trigger(makerOrder, record.maker);
+                    this.trigger(makerOrder, record.maker, slot);
                 }
             }
         }
@@ -99,13 +101,13 @@ class DLOB {
             if (record.taker !== null) {
                 const takerOrder = this.getOrder(record.takerOrderId, record.taker);
                 if (takerOrder) {
-                    this.updateOrder(takerOrder, record.taker, record.takerOrderCumulativeBaseAssetAmountFilled);
+                    this.updateOrder(takerOrder, record.taker, slot, record.takerOrderCumulativeBaseAssetAmountFilled);
                 }
             }
             if (record.maker !== null) {
                 const makerOrder = this.getOrder(record.makerOrderId, record.maker);
                 if (makerOrder) {
-                    this.updateOrder(makerOrder, record.maker, record.makerOrderCumulativeBaseAssetAmountFilled);
+                    this.updateOrder(makerOrder, record.maker, slot, record.makerOrderCumulativeBaseAssetAmountFilled);
                 }
             }
         }
@@ -113,18 +115,18 @@ class DLOB {
             if (record.taker !== null) {
                 const takerOrder = this.getOrder(record.takerOrderId, record.taker);
                 if (takerOrder) {
-                    this.delete(takerOrder, record.taker);
+                    this.delete(takerOrder, record.taker, slot);
                 }
             }
             if (record.maker !== null) {
                 const makerOrder = this.getOrder(record.makerOrderId, record.maker);
                 if (makerOrder) {
-                    this.delete(makerOrder, record.maker);
+                    this.delete(makerOrder, record.maker, slot);
                 }
             }
         }
     }
-    insertOrder(order, userAccount, onInsert) {
+    insertOrder(order, userAccount, slot, onInsert) {
         var _a;
         if (__1.isVariant(order.status, 'init')) {
             return;
@@ -141,21 +143,25 @@ class DLOB {
                 .get(marketType)
                 .add(NodeList_1.getOrderSignature(order.orderId, userAccount));
         }
-        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount);
+        (_a = this.getListForOrder(order, slot)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount);
         if (onInsert) {
             onInsert();
         }
     }
     addOrderList(marketType, marketIndex) {
         this.orderLists.get(marketType).set(marketIndex, {
-            limit: {
-                ask: new NodeList_1.NodeList('limit', 'asc'),
-                bid: new NodeList_1.NodeList('limit', 'desc'),
+            restingLimit: {
+                ask: new NodeList_1.NodeList('restingLimit', 'asc'),
+                bid: new NodeList_1.NodeList('restingLimit', 'desc'),
             },
             floatingLimit: {
                 ask: new NodeList_1.NodeList('floatingLimit', 'asc'),
                 bid: new NodeList_1.NodeList('floatingLimit', 'desc'),
             },
+            takingLimit: {
+                ask: new NodeList_1.NodeList('takingLimit', 'asc'),
+                bid: new NodeList_1.NodeList('takingLimit', 'asc'), // always sort ascending for market orders
+            },
             market: {
                 ask: new NodeList_1.NodeList('market', 'asc'),
                 bid: new NodeList_1.NodeList('market', 'asc'), // always sort ascending for market orders
@@ -166,10 +172,11 @@ class DLOB {
             },
         });
     }
-    updateOrder(order, userAccount, cumulativeBaseAssetAmountFilled, onUpdate) {
+    updateOrder(order, userAccount, slot, cumulativeBaseAssetAmountFilled, onUpdate) {
         var _a;
+        this.updateRestingLimitOrders(slot);
         if (order.baseAssetAmount.eq(cumulativeBaseAssetAmountFilled)) {
-            this.delete(order, userAccount);
+            this.delete(order, userAccount, slot);
             return;
         }
         if (order.baseAssetAmountFilled.eq(cumulativeBaseAssetAmountFilled)) {
@@ -179,16 +186,17 @@ class DLOB {
             ...order,
         };
         newOrder.baseAssetAmountFilled = cumulativeBaseAssetAmountFilled;
-        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.update(newOrder, userAccount);
+        (_a = this.getListForOrder(order, slot)) === null || _a === void 0 ? void 0 : _a.update(newOrder, userAccount);
         if (onUpdate) {
             onUpdate();
         }
     }
-    trigger(order, userAccount, onTrigger) {
+    trigger(order, userAccount, slot, onTrigger) {
         var _a;
         if (__1.isVariant(order.status, 'init')) {
             return;
         }
+        this.updateRestingLimitOrders(slot);
         if (__1.isTriggered(order)) {
             return;
         }
@@ -196,22 +204,23 @@ class DLOB {
         const triggerList = this.orderLists.get(marketType).get(order.marketIndex)
             .trigger[__1.isVariant(order.triggerCondition, 'above') ? 'above' : 'below'];
         triggerList.remove(order, userAccount);
-        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount);
+        (_a = this.getListForOrder(order, slot)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount);
         if (onTrigger) {
             onTrigger();
         }
     }
-    delete(order, userAccount, onDelete) {
+    delete(order, userAccount, slot, onDelete) {
         var _a;
         if (__1.isVariant(order.status, 'init')) {
             return;
         }
-        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.remove(order, userAccount);
+        this.updateRestingLimitOrders(slot);
+        (_a = this.getListForOrder(order, slot)) === null || _a === void 0 ? void 0 : _a.remove(order, userAccount);
         if (onDelete) {
             onDelete();
         }
     }
-    getListForOrder(order) {
+    getListForOrder(order, slot) {
         const isInactiveTriggerOrder = __1.mustBeTriggered(order) && !__1.isTriggered(order);
         let type;
         if (isInactiveTriggerOrder) {
@@ -224,7 +233,8 @@ class DLOB {
             type = 'floatingLimit';
         }
         else {
-            type = 'limit';
+            const isResting = __1.isRestingLimitOrder(order, slot);
+            type = isResting ? 'restingLimit' : 'takingLimit';
         }
         let subType;
         if (isInactiveTriggerOrder) {
@@ -239,6 +249,42 @@ class DLOB {
         }
         return this.orderLists.get(marketType).get(order.marketIndex)[type][subType];
     }
+    updateRestingLimitOrders(slot) {
+        if (slot <= this.maxSlotForRestingLimitOrders) {
+            return;
+        }
+        this.maxSlotForRestingLimitOrders = slot;
+        this.updateRestingLimitOrdersForMarketType(slot, 'perp');
+        this.updateRestingLimitOrdersForMarketType(slot, 'spot');
+    }
+    updateRestingLimitOrdersForMarketType(slot, marketTypeStr) {
+        for (const [_, nodeLists] of this.orderLists.get(marketTypeStr)) {
+            const nodesToUpdate = [];
+            for (const node of nodeLists.takingLimit.ask.getGenerator()) {
+                if (!__1.isRestingLimitOrder(node.order, slot)) {
+                    continue;
+                }
+                nodesToUpdate.push({
+                    side: 'ask',
+                    node,
+                });
+            }
+            for (const node of nodeLists.takingLimit.bid.getGenerator()) {
+                if (!__1.isRestingLimitOrder(node.order, slot)) {
+                    continue;
+                }
+                nodesToUpdate.push({
+                    side: 'bid',
+                    node,
+                });
+            }
+            for (const nodeToUpdate of nodesToUpdate) {
+                const { side, node } = nodeToUpdate;
+                nodeLists.takingLimit[side].remove(node.order, node.userAccount);
+                nodeLists.restingLimit[side].insert(node.order, marketTypeStr, node.userAccount);
+            }
+        }
+    }
     getOrder(orderId, userAccount) {
         for (const nodeList of this.getNodeLists()) {
             const node = nodeList.get(orderId, userAccount);
@@ -253,42 +299,45 @@ class DLOB {
             return [];
         }
         const isAmmPaused = exchangeStatus_1.ammPaused(stateAccount, marketAccount);
-        const marketOrderNodesToFill = this.findMarketNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid);
-        const limitOrderNodesToFill = this.findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid);
+        const minAuctionDuration = __1.isVariant(marketType, 'perp')
+            ? stateAccount.minPerpAuctionDuration
+            : 0;
+        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
+        const takingOrderNodesToFill = this.findTakingNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
         // get expired market nodes
         const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
-        return marketOrderNodesToFill.concat(limitOrderNodesToFill, expiredNodesToFill);
+        return restingLimitOrderNodesToFill.concat(takingOrderNodesToFill, expiredNodesToFill);
     }
-    findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
+    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData, fallbackAsk, fallbackBid);
+        const crossingNodes = this.findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData, minAuctionDuration, fallbackAsk, fallbackBid);
         for (const crossingNode of crossingNodes) {
             nodesToFill.push(crossingNode);
         }
         if (fallbackBid && !isAmmPaused) {
-            const askGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
+            const askGenerator = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
             const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, fallbackBid, (askPrice, fallbackPrice) => {
                 return askPrice.lte(fallbackPrice);
-            });
+            }, minAuctionDuration);
             for (const askCrossingFallback of asksCrossingFallback) {
                 nodesToFill.push(askCrossingFallback);
             }
         }
         if (fallbackAsk && !isAmmPaused) {
-            const bidGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
+            const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
             const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, fallbackAsk, (bidPrice, fallbackPrice) => {
                 return bidPrice.gte(fallbackPrice);
-            });
+            }, minAuctionDuration);
             for (const bidCrossingFallback of bidsCrossingFallback) {
                 nodesToFill.push(bidCrossingFallback);
             }
         }
         return nodesToFill;
     }
-    findMarketNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
+    findTakingNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
-        const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitBids.bind(this), (takerPrice, makerPrice) => {
+        let takingOrderGenerator = this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData);
+        const takingAsksCrossingBids = this.findTakingNodesCrossingMakerNodes(marketIndex, slot, marketType, oraclePriceData, takingOrderGenerator, this.getMakerLimitBids.bind(this), (takerPrice, makerPrice) => {
             if (__1.isVariant(marketType, 'spot')) {
                 if (takerPrice === undefined) {
                     return false;
@@ -299,20 +348,20 @@ class DLOB {
             }
             return takerPrice === undefined || takerPrice.lte(makerPrice);
         }, fallbackAsk);
-        for (const marketAskCrossingBid of marketAsksCrossingBids) {
-            nodesToFill.push(marketAskCrossingBid);
+        for (const takingAskCrossingBid of takingAsksCrossingBids) {
+            nodesToFill.push(takingAskCrossingBid);
         }
         if (fallbackBid && !isAmmPaused) {
-            marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
-            const marketAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, marketOrderGenerator, fallbackBid, (takerPrice, fallbackPrice) => {
+            takingOrderGenerator = this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData);
+            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackBid, (takerPrice, fallbackPrice) => {
                 return takerPrice === undefined || takerPrice.lte(fallbackPrice);
-            });
-            for (const marketAskCrossingFallback of marketAsksCrossingFallback) {
-                nodesToFill.push(marketAskCrossingFallback);
+            }, minAuctionDuration);
+            for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
+                nodesToFill.push(takingAskCrossingFallback);
             }
         }
-        marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
-        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitAsks.bind(this), (takerPrice, makerPrice) => {
+        takingOrderGenerator = this.getTakingBids(marketIndex, marketType, slot, oraclePriceData);
+        const takingBidsToFill = this.findTakingNodesCrossingMakerNodes(marketIndex, slot, marketType, oraclePriceData, takingOrderGenerator, this.getMakerLimitAsks.bind(this), (takerPrice, makerPrice) => {
             if (__1.isVariant(marketType, 'spot')) {
                 if (takerPrice === undefined) {
                     return false;
@@ -323,21 +372,21 @@ class DLOB {
             }
             return takerPrice === undefined || takerPrice.gte(makerPrice);
         }, fallbackBid);
-        for (const marketBidToFill of marketBidsToFill) {
-            nodesToFill.push(marketBidToFill);
+        for (const takingBidToFill of takingBidsToFill) {
+            nodesToFill.push(takingBidToFill);
         }
         if (fallbackAsk && !isAmmPaused) {
-            marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
-            const marketBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, marketOrderGenerator, fallbackAsk, (takerPrice, fallbackPrice) => {
+            takingOrderGenerator = this.getTakingBids(marketIndex, marketType, slot, oraclePriceData);
+            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackAsk, (takerPrice, fallbackPrice) => {
                 return takerPrice === undefined || takerPrice.gte(fallbackPrice);
-            });
-            for (const marketBidCrossingFallback of marketBidsCrossingFallback) {
+            }, minAuctionDuration);
+            for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
                 nodesToFill.push(marketBidCrossingFallback);
             }
         }
         return nodesToFill;
     }
-    findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, takerNodeGenerator, makerNodeGeneratorFn, doesCross, fallbackPrice) {
+    findTakingNodesCrossingMakerNodes(marketIndex, slot, marketType, oraclePriceData, takerNodeGenerator, makerNodeGeneratorFn, doesCross, fallbackPrice) {
         const nodesToFill = new Array();
         for (const takerNode of takerNodeGenerator) {
             const makerNodeGenerator = makerNodeGeneratorFn(marketIndex, slot, marketType, oraclePriceData, fallbackPrice);
@@ -367,11 +416,11 @@ class DLOB {
                 const newMakerOrder = { ...makerOrder };
                 newMakerOrder.baseAssetAmountFilled =
                     makerOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOrder(newMakerOrder).update(newMakerOrder, makerNode.userAccount);
+                this.getListForOrder(newMakerOrder, slot).update(newMakerOrder, makerNode.userAccount);
                 const newTakerOrder = { ...takerOrder };
                 newTakerOrder.baseAssetAmountFilled =
                     takerOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOrder(newTakerOrder).update(newTakerOrder, takerNode.userAccount);
+                this.getListForOrder(newTakerOrder, slot).update(newTakerOrder, takerNode.userAccount);
                 if (newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)) {
                     break;
                 }
@@ -379,7 +428,7 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, fallbackPrice, doesCross) {
+    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, fallbackPrice, doesCross, minAuctionDuration) {
         var _a;
         const nodesToFill = new Array();
         let nextNode = nodeGenerator.next();
@@ -393,7 +442,8 @@ class DLOB {
             // order crosses if there is no limit price or it crosses fallback price
             const crosses = doesCross(nodePrice, fallbackPrice);
             // fallback is available if auction is complete or it's a spot order
-            const fallbackAvailable = __1.isVariant(marketType, 'spot') || __1.isAuctionComplete(node.order, slot);
+            const fallbackAvailable = __1.isVariant(marketType, 'spot') ||
+                __1.isFallbackAvailableLiquiditySource(node.order, minAuctionDuration, slot);
             if (crosses && fallbackAvailable) {
                 nodesToFill.push({
                     node: node,
@@ -413,12 +463,14 @@ class DLOB {
         }
         // All bids/asks that can expire
         const bidGenerators = [
-            nodeLists.limit.bid.getGenerator(),
+            nodeLists.takingLimit.bid.getGenerator(),
+            nodeLists.restingLimit.bid.getGenerator(),
             nodeLists.floatingLimit.bid.getGenerator(),
             nodeLists.market.bid.getGenerator(),
         ];
         const askGenerators = [
-            nodeLists.limit.ask.getGenerator(),
+            nodeLists.takingLimit.ask.getGenerator(),
+            nodeLists.restingLimit.ask.getGenerator(),
             nodeLists.floatingLimit.ask.getGenerator(),
             nodeLists.market.ask.getGenerator(),
         ];
@@ -442,52 +494,50 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findJitAuctionNodesToFill(marketIndex, slot, marketType) {
+    findJitAuctionNodesToFill(marketIndex, slot, oraclePriceData, marketType) {
         const nodesToFill = new Array();
         // Then see if there are orders still in JIT auction
-        for (const marketBid of this.getMarketBids(marketIndex, marketType)) {
-            if (!__1.isAuctionComplete(marketBid.order, slot)) {
-                nodesToFill.push({
-                    node: marketBid,
-                });
-            }
+        for (const marketBid of this.getTakingBids(marketIndex, marketType, slot, oraclePriceData)) {
+            nodesToFill.push({
+                node: marketBid,
+            });
         }
-        for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
-            if (!__1.isAuctionComplete(marketAsk.order, slot)) {
-                nodesToFill.push({
-                    node: marketAsk,
-                });
-            }
+        for (const marketAsk of this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData)) {
+            nodesToFill.push({
+                node: marketAsk,
+            });
         }
         return nodesToFill;
     }
-    *getMarketBids(marketIndex, marketType) {
+    *getTakingBids(marketIndex, marketType, slot, oraclePriceData) {
         const marketTypeStr = __1.getVariant(marketType);
         const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
         if (!orderLists) {
             return;
         }
-        const generator = orderLists.market.bid.getGenerator();
-        for (const marketBidNode of generator) {
-            if (marketBidNode.isBaseFilled()) {
-                continue;
-            }
-            yield marketBidNode;
-        }
+        this.updateRestingLimitOrders(slot);
+        const generatorList = [
+            orderLists.market.bid.getGenerator(),
+            orderLists.takingLimit.bid.getGenerator(),
+        ];
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode) => {
+            return bestNode.order.slot.lt(currentNode.order.slot);
+        });
     }
-    *getMarketAsks(marketIndex, marketType) {
+    *getTakingAsks(marketIndex, marketType, slot, oraclePriceData) {
         const marketTypeStr = __1.getVariant(marketType);
         const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
         if (!orderLists) {
             return;
         }
-        const generator = orderLists.market.ask.getGenerator();
-        for (const marketAskNode of generator) {
-            if (marketAskNode.isBaseFilled()) {
-                continue;
-            }
-            yield marketAskNode;
-        }
+        this.updateRestingLimitOrders(slot);
+        const generatorList = [
+            orderLists.market.ask.getGenerator(),
+            orderLists.takingLimit.ask.getGenerator(),
+        ];
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode) => {
+            return bestNode.order.slot.lt(currentNode.order.slot);
+        });
     }
     *getBestNode(generatorList, oraclePriceData, slot, compareFcn) {
         const generators = generatorList.map((generator) => {
@@ -507,16 +557,7 @@ class DLOB {
                 }
                 const bestValue = bestGenerator.next.value;
                 const currentValue = currentGenerator.next.value;
-                // always return the market orders first
-                if (bestValue.order && __1.isMarketOrder(bestValue.order)) {
-                    return bestGenerator;
-                }
-                if (currentValue.order && __1.isMarketOrder(currentValue.order)) {
-                    return currentGenerator;
-                }
-                const bestPrice = bestValue.getPrice(oraclePriceData, slot);
-                const currentPrice = currentValue.getPrice(oraclePriceData, slot);
-                return compareFcn(bestPrice, currentPrice)
+                return compareFcn(bestValue, currentValue, slot, oraclePriceData)
                     ? bestGenerator
                     : currentGenerator;
             });
@@ -534,58 +575,59 @@ class DLOB {
             }
         }
     }
-    *getLimitAsks(marketIndex, slot, marketType, oraclePriceData) {
+    *getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData) {
         if (__1.isVariant(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot asks');
         }
+        this.updateRestingLimitOrders(slot);
         const marketTypeStr = __1.getVariant(marketType);
         const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
         if (!nodeLists) {
             return;
         }
         const generatorList = [
-            nodeLists.limit.ask.getGenerator(),
+            nodeLists.restingLimit.ask.getGenerator(),
             nodeLists.floatingLimit.ask.getGenerator(),
         ];
-        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
-            return bestPrice.lt(currentPrice);
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode, slot, oraclePriceData) => {
+            return bestNode
+                .getPrice(oraclePriceData, slot)
+                .lt(currentNode.getPrice(oraclePriceData, slot));
         });
     }
     /**
-     * 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
+     * Filters the limit asks that are resting and do not cross fallback bid
+     * Taking orders can only fill against orders that meet this criteria
      *
      * @returns
      */
     *getMakerLimitAsks(marketIndex, slot, marketType, oraclePriceData, fallbackBid) {
-        for (const node of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
-            if (this.isRestingLimitOrder(node.order, slot)) {
-                yield node;
-            }
-            else if (fallbackBid &&
-                node.getPrice(oraclePriceData, slot).gt(fallbackBid)) {
-                yield node;
+        for (const node of this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
+            if (fallbackBid &&
+                node.getPrice(oraclePriceData, slot).lte(fallbackBid)) {
+                continue;
             }
+            yield node;
         }
     }
-    isRestingLimitOrder(order, slot) {
-        return order.postOnly || new __1.BN(slot).sub(order.slot).gte(new __1.BN(45));
-    }
-    *getLimitBids(marketIndex, slot, marketType, oraclePriceData) {
+    *getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData) {
         if (__1.isVariant(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot bids');
         }
+        this.updateRestingLimitOrders(slot);
         const marketTypeStr = __1.getVariant(marketType);
         const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
         if (!nodeLists) {
             return;
         }
         const generatorList = [
-            nodeLists.limit.bid.getGenerator(),
+            nodeLists.restingLimit.bid.getGenerator(),
             nodeLists.floatingLimit.bid.getGenerator(),
         ];
-        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
-            return bestPrice.gt(currentPrice);
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode, slot, oraclePriceData) => {
+            return bestNode
+                .getPrice(oraclePriceData, slot)
+                .gt(currentNode.getPrice(oraclePriceData, slot));
         });
     }
     /**
@@ -595,14 +637,12 @@ class DLOB {
      * @returns
      */
     *getMakerLimitBids(marketIndex, slot, marketType, oraclePriceData, fallbackAsk) {
-        for (const node of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
-            if (this.isRestingLimitOrder(node.order, slot)) {
-                yield node;
-            }
-            else if (fallbackAsk &&
-                node.getPrice(oraclePriceData, slot).lt(fallbackAsk)) {
-                yield node;
+        for (const node of this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
+            if (fallbackAsk &&
+                node.getPrice(oraclePriceData, slot).gte(fallbackAsk)) {
+                continue;
             }
+            yield node;
         }
     }
     *getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
@@ -610,15 +650,32 @@ class DLOB {
             throw new Error('Must provide OraclePriceData to get spot asks');
         }
         const generatorList = [
-            this.getMarketAsks(marketIndex, marketType),
-            this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData),
+            this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData),
+            this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData),
         ];
         const marketTypeStr = __1.getVariant(marketType);
         if (marketTypeStr === 'perp' && fallbackAsk) {
             generatorList.push(NodeList_1.getVammNodeGenerator(fallbackAsk));
         }
-        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
-            return bestPrice.lt(currentPrice);
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode, slot, oraclePriceData) => {
+            const bestNodeTaking = bestNode.order
+                ? __1.isTakingOrder(bestNode.order, slot)
+                : false;
+            const currentNodeTaking = currentNode.order
+                ? __1.isTakingOrder(currentNode.order, slot)
+                : false;
+            if (bestNodeTaking && currentNodeTaking) {
+                return bestNode.order.slot.lt(currentNode.order.slot);
+            }
+            if (bestNodeTaking) {
+                return true;
+            }
+            if (currentNodeTaking) {
+                return false;
+            }
+            return bestNode
+                .getPrice(oraclePriceData, slot)
+                .lt(currentNode.getPrice(oraclePriceData, slot));
         });
     }
     *getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
@@ -626,37 +683,60 @@ class DLOB {
             throw new Error('Must provide OraclePriceData to get spot bids');
         }
         const generatorList = [
-            this.getMarketBids(marketIndex, marketType),
-            this.getLimitBids(marketIndex, slot, marketType, oraclePriceData),
+            this.getTakingBids(marketIndex, marketType, slot, oraclePriceData),
+            this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData),
         ];
         const marketTypeStr = __1.getVariant(marketType);
         if (marketTypeStr === 'perp' && fallbackBid) {
             generatorList.push(NodeList_1.getVammNodeGenerator(fallbackBid));
         }
-        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
-            return bestPrice.gt(currentPrice);
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestNode, currentNode, slot, oraclePriceData) => {
+            const bestNodeTaking = bestNode.order
+                ? __1.isTakingOrder(bestNode.order, slot)
+                : false;
+            const currentNodeTaking = currentNode.order
+                ? __1.isTakingOrder(currentNode.order, slot)
+                : false;
+            if (bestNodeTaking && currentNodeTaking) {
+                return bestNode.order.slot.lt(currentNode.order.slot);
+            }
+            if (bestNodeTaking) {
+                return true;
+            }
+            if (currentNodeTaking) {
+                return false;
+            }
+            return bestNode
+                .getPrice(oraclePriceData, slot)
+                .gt(currentNode.getPrice(oraclePriceData, slot));
         });
     }
-    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData, fallbackAsk, fallbackBid) {
+    findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData, minAuctionDuration, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        for (const askNode of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
-            for (const bidNode of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
+        for (const askNode of this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
+            const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
+            for (const bidNode of bidGenerator) {
                 const bidPrice = bidNode.getPrice(oraclePriceData, slot);
                 const askPrice = askNode.getPrice(oraclePriceData, slot);
-                // orders don't cross - we're done walking the book
+                // orders don't cross
                 if (bidPrice.lt(askPrice)) {
-                    return nodesToFill;
+                    break;
                 }
                 const bidOrder = bidNode.order;
                 const askOrder = askNode.order;
                 // Can't match orders from the same user
                 const sameUser = bidNode.userAccount.equals(askNode.userAccount);
-                if (sameUser || (bidOrder.postOnly && askOrder.postOnly)) {
+                if (sameUser) {
+                    continue;
+                }
+                const makerAndTaker = this.determineMakerAndTaker(askNode, bidNode);
+                // unable to match maker and taker due to post only or slot
+                if (!makerAndTaker) {
                     continue;
                 }
-                const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
+                const { takerNode, makerNode } = makerAndTaker;
                 // extra guard against bad fills for limit orders where auction is incomplete
-                if (!__1.isAuctionComplete(takerNode.order, slot)) {
+                if (!__1.isFallbackAvailableLiquiditySource(takerNode.order, minAuctionDuration, slot)) {
                     let bidPrice;
                     let askPrice;
                     if (__1.isVariant(takerNode.order.direction, 'long')) {
@@ -677,12 +757,12 @@ class DLOB {
                 const newBidOrder = { ...bidOrder };
                 newBidOrder.baseAssetAmountFilled =
                     bidOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
+                this.getListForOrder(newBidOrder, slot).update(newBidOrder, bidNode.userAccount);
                 // ask completely filled
                 const newAskOrder = { ...askOrder };
                 newAskOrder.baseAssetAmountFilled =
                     askOrder.baseAssetAmountFilled.add(baseFilled);
-                this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
+                this.getListForOrder(newAskOrder, slot).update(newAskOrder, askNode.userAccount);
                 nodesToFill.push({
                     node: takerNode,
                     makerNode: makerNode,
@@ -695,30 +775,23 @@ class DLOB {
         return nodesToFill;
     }
     determineMakerAndTaker(askNode, bidNode) {
-        if (bidNode.order.postOnly) {
-            return {
-                takerNode: askNode,
-                makerNode: bidNode,
-            };
-        }
-        else if (askNode.order.postOnly) {
+        const askSlot = askNode.order.slot.add(new __1.BN(askNode.order.auctionDuration));
+        const bidSlot = bidNode.order.slot.add(new __1.BN(bidNode.order.auctionDuration));
+        if (askSlot.lte(bidSlot) && !bidNode.order.postOnly) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
             };
         }
-        else if (askNode.order.slot.lt(bidNode.order.slot)) {
-            return {
-                takerNode: bidNode,
-                makerNode: askNode,
-            };
-        }
-        else {
+        else if (bidSlot.lte(askSlot) && !askNode.order.postOnly) {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
             };
         }
+        else {
+            return undefined;
+        }
     }
     getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
         return this.getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData)
@@ -743,11 +816,9 @@ class DLOB {
         if (triggerAboveList) {
             for (const node of triggerAboveList.getGenerator()) {
                 if (oraclePrice.gt(node.order.triggerPrice)) {
-                    if (__1.isAuctionComplete(node.order, slot)) {
-                        nodesToTrigger.push({
-                            node: node,
-                        });
-                    }
+                    nodesToTrigger.push({
+                        node: node,
+                    });
                 }
                 else {
                     break;
@@ -760,11 +831,9 @@ class DLOB {
         if (triggerBelowList) {
             for (const node of triggerBelowList.getGenerator()) {
                 if (oraclePrice.lt(node.order.triggerPrice)) {
-                    if (__1.isAuctionComplete(node.order, slot)) {
-                        nodesToTrigger.push({
-                            node: node,
-                        });
-                    }
+                    nodesToTrigger.push({
+                        node: node,
+                    });
                 }
                 else {
                     break;
@@ -830,8 +899,10 @@ class DLOB {
     }
     *getNodeLists() {
         for (const [_, nodeLists] of this.orderLists.get('perp')) {
-            yield nodeLists.limit.bid;
-            yield nodeLists.limit.ask;
+            yield nodeLists.restingLimit.bid;
+            yield nodeLists.restingLimit.ask;
+            yield nodeLists.takingLimit.bid;
+            yield nodeLists.takingLimit.ask;
             yield nodeLists.market.bid;
             yield nodeLists.market.ask;
             yield nodeLists.floatingLimit.bid;
@@ -840,8 +911,10 @@ class DLOB {
             yield nodeLists.trigger.below;
         }
         for (const [_, nodeLists] of this.orderLists.get('spot')) {
-            yield nodeLists.limit.bid;
-            yield nodeLists.limit.ask;
+            yield nodeLists.restingLimit.bid;
+            yield nodeLists.restingLimit.ask;
+            yield nodeLists.takingLimit.bid;
+            yield nodeLists.takingLimit.ask;
             yield nodeLists.market.bid;
             yield nodeLists.market.ask;
             yield nodeLists.floatingLimit.bid;