@drift-labs/sdk 2.0.13 → 2.0.15

package/lib/dlob/DLOB.js

@@ -180,98 +180,141 @@ class DLOB {
         if ((0, exchangeStatus_1.fillPaused)(this.stateAccount, marketAccount)) {
             return [];
         }
-        // Find all the crossing nodes
-        const crossingNodesToFill = this.findCrossingNodesToFill(marketIndex, slot, marketType, oraclePriceData);
-        let fallbackCrossingNodesToFill = new Array();
-        if (!(0, exchangeStatus_1.ammPaused)(this.stateAccount, marketAccount)) {
-            fallbackCrossingNodesToFill = this.findFallbackCrossingNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, marketType, oraclePriceData);
-        }
+        const isAmmPaused = (0, exchangeStatus_1.ammPaused)(this.stateAccount, marketAccount);
+        const marketOrderNodesToFill = this.findMarketNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid);
+        const limitOrderNodesToFill = this.findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid);
         // get expired market nodes
         const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
-        return crossingNodesToFill.concat(fallbackCrossingNodesToFill, expiredNodesToFill);
+        return marketOrderNodesToFill.concat(limitOrderNodesToFill, expiredNodesToFill);
     }
-    findCrossingNodesToFill(marketIndex, slot, marketType, oraclePriceData) {
+    findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        const askGenerator = this.getAsks(marketIndex, undefined, // dont include vask
-        slot, marketType, oraclePriceData);
-        const bidGenerator = this.getBids(marketIndex, undefined, // dont include vbid
-        slot, marketType, oraclePriceData);
-        let nextAsk = askGenerator.next();
-        let nextBid = bidGenerator.next();
-        // First try to find orders that cross
-        while (!nextAsk.done && !nextBid.done) {
-            const { crossingNodes, exhaustedSide } = this.findCrossingOrders(nextAsk.value, nextBid.value, oraclePriceData, slot);
-            if (exhaustedSide === 'bid') {
-                nextBid = bidGenerator.next();
-            }
-            else if (exhaustedSide === 'ask') {
-                nextAsk = askGenerator.next();
-            }
-            else if (exhaustedSide === 'both') {
-                nextBid = bidGenerator.next();
-                nextAsk = askGenerator.next();
+        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
+        for (const crossingNode of crossingNodes) {
+            nodesToFill.push(crossingNode);
+        }
+        if (fallbackBid && !isAmmPaused) {
+            const askGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
+            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, fallbackBid, (askPrice, fallbackPrice) => {
+                return askPrice.lte(fallbackPrice);
+            });
+            for (const askCrossingFallback of asksCrossingFallback) {
+                nodesToFill.push(askCrossingFallback);
             }
-            else if (exhaustedSide === 'nocross') {
-                break;
+        }
+        if (fallbackAsk && !isAmmPaused) {
+            const bidGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
+            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, fallbackAsk, (bidPrice, fallbackPrice) => {
+                return bidPrice.gte(fallbackPrice);
+            });
+            for (const bidCrossingFallback of bidsCrossingFallback) {
+                nodesToFill.push(bidCrossingFallback);
             }
-            else {
-                console.error(`invalid exhaustedSide: ${exhaustedSide}`);
-                break;
+        }
+        return nodesToFill;
+    }
+    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) => {
+            return takerPrice === undefined || takerPrice.lte(makerPrice);
+        });
+        for (const marketAskCrossingBid of marketAsksCrossingBids) {
+            nodesToFill.push(marketAskCrossingBid);
+        }
+        if (fallbackBid && !isAmmPaused) {
+            marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
+            const marketAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, marketOrderGenerator, fallbackBid, (takerPrice, fallbackPrice) => {
+                return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+            });
+            for (const marketAskCrossingFallback of marketAsksCrossingFallback) {
+                nodesToFill.push(marketAskCrossingFallback);
             }
-            for (const crossingNode of crossingNodes) {
-                nodesToFill.push(crossingNode);
+        }
+        marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
+        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getLimitAsks.bind(this), (takerPrice, fallbackPrice) => {
+            return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+        });
+        for (const marketBidToFill of marketBidsToFill) {
+            nodesToFill.push(marketBidToFill);
+        }
+        if (fallbackAsk && !isAmmPaused) {
+            marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
+            const marketBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, marketOrderGenerator, fallbackAsk, (takerPrice, fallbackPrice) => {
+                return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+            });
+            for (const marketBidCrossingFallback of marketBidsCrossingFallback) {
+                nodesToFill.push(marketBidCrossingFallback);
             }
         }
         return nodesToFill;
     }
-    findFallbackCrossingNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, marketType, oraclePriceData) {
-        var _a, _b;
+    findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, takerNodeGenerator, makerNodeGeneratorFn, doesCross) {
         const nodesToFill = new Array();
-        const askGenerator = this.getAsks(marketIndex, undefined, // dont include vask
-        slot, marketType, oraclePriceData);
-        const bidGenerator = this.getBids(marketIndex, undefined, // dont include vbid
-        slot, marketType, oraclePriceData);
-        let nextAsk = askGenerator.next();
-        let nextBid = bidGenerator.next();
-        // check for asks that cross fallbackBid
-        while (!nextAsk.done && fallbackBid !== undefined) {
-            const askNode = nextAsk.value;
-            if ((0, __1.isVariant)(marketType, 'spot') && ((_a = askNode.order) === null || _a === void 0 ? void 0 : _a.postOnly)) {
-                nextAsk = askGenerator.next();
-                continue;
-            }
-            const askLimitPrice = (0, __1.getOptionalLimitPrice)(askNode.order, oraclePriceData, slot);
-            // order crosses if there is no limit price or it crosses fallback price
-            const crosses = askLimitPrice === undefined || askLimitPrice.lte(fallbackBid);
-            // fallback is available if auction is complete or it's a spot order
-            const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') || (0, __1.isAuctionComplete)(askNode.order, slot);
-            if (crosses && fallbackAvailable) {
+        for (const takerNode of takerNodeGenerator) {
+            const makerNodeGenerator = makerNodeGeneratorFn(marketIndex, slot, marketType, oraclePriceData);
+            for (const makerNode of makerNodeGenerator) {
+                const bidUserAuthority = this.userMap.getUserAuthority(makerNode.userAccount.toString());
+                const askUserAuthority = this.userMap.getUserAuthority(takerNode.userAccount.toString());
+                // Can't match orders from the same authority
+                const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+                if (sameAuthority) {
+                    continue;
+                }
+                const makerPrice = makerNode.getPrice(oraclePriceData, slot);
+                const takerPrice = takerNode.getPrice(oraclePriceData, slot);
+                const ordersCross = doesCross(takerPrice, makerPrice);
+                if (!ordersCross) {
+                    // market orders aren't sorted by price, they are sorted by time, so we need to traverse
+                    // through all of em
+                    break;
+                }
                 nodesToFill.push({
-                    node: askNode,
-                    makerNode: undefined, // filled by fallback
+                    node: takerNode,
+                    makerNode: makerNode,
                 });
+                const makerOrder = makerNode.order;
+                const takerOrder = takerNode.order;
+                const makerBaseRemaining = makerOrder.baseAssetAmount.sub(makerOrder.baseAssetAmountFilled);
+                const takerBaseRemaining = takerOrder.baseAssetAmount.sub(takerOrder.baseAssetAmountFilled);
+                const baseFilled = __1.BN.min(makerBaseRemaining, takerBaseRemaining);
+                const newMakerOrder = { ...makerOrder };
+                newMakerOrder.baseAssetAmountFilled =
+                    makerOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newMakerOrder).update(newMakerOrder, makerNode.userAccount);
+                const newTakerOrder = { ...takerOrder };
+                newTakerOrder.baseAssetAmountFilled =
+                    takerOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newTakerOrder).update(newTakerOrder, takerNode.userAccount);
+                if (newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)) {
+                    break;
+                }
             }
-            nextAsk = askGenerator.next();
         }
-        // check for bids that cross fallbackAsk
-        while (!nextBid.done && fallbackAsk !== undefined) {
-            const bidNode = nextBid.value;
-            if ((0, __1.isVariant)(marketType, 'spot') && ((_b = bidNode.order) === null || _b === void 0 ? void 0 : _b.postOnly)) {
-                nextBid = bidGenerator.next();
+        return nodesToFill;
+    }
+    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, fallbackPrice, doesCross) {
+        var _a;
+        const nodesToFill = new Array();
+        let nextNode = nodeGenerator.next();
+        while (!nextNode.done) {
+            const node = nextNode.value;
+            if ((0, __1.isVariant)(marketType, 'spot') && ((_a = node.order) === null || _a === void 0 ? void 0 : _a.postOnly)) {
+                nextNode = nodeGenerator.next();
                 continue;
             }
-            const bidLimitPrice = (0, __1.getOptionalLimitPrice)(bidNode.order, oraclePriceData, slot);
+            const nodePrice = (0, __1.getLimitPrice)(node.order, oraclePriceData, slot);
             // order crosses if there is no limit price or it crosses fallback price
-            const crosses = bidLimitPrice === undefined || bidLimitPrice.gte(fallbackAsk);
+            const crosses = doesCross(nodePrice, fallbackPrice);
             // fallback is available if auction is complete or it's a spot order
-            const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') || (0, __1.isAuctionComplete)(bidNode.order, slot);
+            const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') || (0, __1.isAuctionComplete)(node.order, slot);
             if (crosses && fallbackAvailable) {
                 nodesToFill.push({
-                    node: bidNode,
+                    node: node,
                     makerNode: undefined, // filled by fallback
                 });
             }
-            nextBid = bidGenerator.next();
+            nextNode = nodeGenerator.next();
         }
         return nodesToFill;
     }
@@ -329,55 +372,60 @@ class DLOB {
         }
         return nodesToFill;
     }
-    getMarketBids(marketIndex, marketType) {
+    *getMarketBids(marketIndex, marketType) {
         const marketTypeStr = (0, __1.getVariant)(marketType);
-        return this.orderLists
+        const generator = this.orderLists
             .get(marketTypeStr)
             .get(marketIndex)
             .market.bid.getGenerator();
+        for (const marketBidNode of generator) {
+            if (marketBidNode.isBaseFilled()) {
+                continue;
+            }
+            yield marketBidNode;
+        }
     }
-    getMarketAsks(marketIndex, marketType) {
+    *getMarketAsks(marketIndex, marketType) {
         const marketTypeStr = (0, __1.getVariant)(marketType);
-        return this.orderLists
+        const generator = this.orderLists
             .get(marketTypeStr)
             .get(marketIndex)
             .market.ask.getGenerator();
-    }
-    *getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
-        if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
-            throw new Error('Must provide OraclePriceData to get spot asks');
-        }
-        const marketTypeStr = (0, __1.getVariant)(marketType);
-        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
-        const generatorList = [
-            nodeLists.limit.ask.getGenerator(),
-            nodeLists.floatingLimit.ask.getGenerator(),
-            nodeLists.market.ask.getGenerator(),
-        ];
-        if (marketTypeStr === 'perp' && fallbackAsk) {
-            generatorList.push((0, NodeList_1.getVammNodeGenerator)(fallbackAsk));
-        }
-        if (generatorList.length === 0) {
-            throw new Error('No ask generators found');
+        for (const marketAskNode of generator) {
+            if (marketAskNode.isBaseFilled()) {
+                continue;
+            }
+            yield marketAskNode;
         }
-        const askGenerators = generatorList.map((generator) => {
+    }
+    *getBestNode(generatorList, oraclePriceData, slot, compareFcn) {
+        const generators = generatorList.map((generator) => {
             return {
                 next: generator.next(),
                 generator,
             };
         });
-        let asksExhausted = false;
-        while (!asksExhausted) {
-            const bestGenerator = askGenerators.reduce((bestGenerator, currentGenerator) => {
+        let sideExhausted = false;
+        while (!sideExhausted) {
+            const bestGenerator = generators.reduce((bestGenerator, currentGenerator) => {
                 if (currentGenerator.next.done) {
                     return bestGenerator;
                 }
                 if (bestGenerator.next.done) {
                     return currentGenerator;
                 }
-                const bestAskPrice = bestGenerator.next.value.getPrice(oraclePriceData, slot);
-                const currentAskPrice = currentGenerator.next.value.getPrice(oraclePriceData, slot);
-                return bestAskPrice.lt(currentAskPrice)
+                const bestValue = bestGenerator.next.value;
+                const currentValue = currentGenerator.next.value;
+                // always return the market orders first
+                if (bestValue.order && (0, __1.isMarketOrder)(bestValue.order)) {
+                    return bestGenerator;
+                }
+                if (currentValue.order && (0, __1.isMarketOrder)(currentValue.order)) {
+                    return currentGenerator;
+                }
+                const bestPrice = bestValue.getPrice(oraclePriceData, slot);
+                const currentPrice = currentValue.getPrice(oraclePriceData, slot);
+                return compareFcn(bestPrice, currentPrice)
                     ? bestGenerator
                     : currentGenerator;
             });
@@ -399,11 +447,25 @@ class DLOB {
                 bestGenerator.next = bestGenerator.generator.next();
             }
             else {
-                asksExhausted = true;
+                sideExhausted = true;
             }
         }
     }
-    *getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
+    *getLimitAsks(marketIndex, slot, marketType, oraclePriceData) {
+        if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
+            throw new Error('Must provide OraclePriceData to get spot asks');
+        }
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        const generatorList = [
+            nodeLists.limit.ask.getGenerator(),
+            nodeLists.floatingLimit.ask.getGenerator(),
+        ];
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
+            return bestPrice.lt(currentPrice);
+        });
+    }
+    *getLimitBids(marketIndex, slot, marketType, oraclePriceData) {
         if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot bids');
         }
@@ -412,190 +474,109 @@ class DLOB {
         const generatorList = [
             nodeLists.limit.bid.getGenerator(),
             nodeLists.floatingLimit.bid.getGenerator(),
-            nodeLists.market.bid.getGenerator(),
         ];
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
+            return bestPrice.gt(currentPrice);
+        });
+    }
+    *getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
+        if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
+            throw new Error('Must provide OraclePriceData to get spot asks');
+        }
+        const generatorList = [
+            this.getMarketAsks(marketIndex, marketType),
+            this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData),
+        ];
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        if (marketTypeStr === 'perp' && fallbackAsk) {
+            generatorList.push((0, NodeList_1.getVammNodeGenerator)(fallbackAsk));
+        }
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
+            return bestPrice.lt(currentPrice);
+        });
+    }
+    *getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
+        if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
+            throw new Error('Must provide OraclePriceData to get spot bids');
+        }
+        const generatorList = [
+            this.getMarketBids(marketIndex, marketType),
+            this.getLimitBids(marketIndex, slot, marketType, oraclePriceData),
+        ];
+        const marketTypeStr = (0, __1.getVariant)(marketType);
         if (marketTypeStr === 'perp' && fallbackBid) {
             generatorList.push((0, NodeList_1.getVammNodeGenerator)(fallbackBid));
         }
-        if (generatorList.length === 0) {
-            throw new Error('No bid generators found');
-        }
-        const bidGenerators = generatorList.map((generator) => {
-            return {
-                next: generator.next(),
-                generator,
-            };
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
+            return bestPrice.gt(currentPrice);
         });
-        let bidsExhausted = false; // there will always be the fallbackBid
-        while (!bidsExhausted) {
-            const bestGenerator = bidGenerators.reduce((bestGenerator, currentGenerator) => {
-                if (currentGenerator.next.done) {
-                    return bestGenerator;
-                }
-                if (bestGenerator.next.done) {
-                    return currentGenerator;
+    }
+    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData) {
+        const nodesToFill = new Array();
+        for (const askNode of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
+            for (const bidNode of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
+                const bidPrice = bidNode.getPrice(oraclePriceData, slot);
+                const askPrice = askNode.getPrice(oraclePriceData, slot);
+                // orders don't cross - we're done walking the book
+                if (bidPrice.lt(askPrice)) {
+                    return nodesToFill;
                 }
-                const bestBidPrice = bestGenerator.next.value.getPrice(oraclePriceData, slot);
-                const currentBidPrice = currentGenerator.next.value.getPrice(oraclePriceData, slot);
-                return bestBidPrice.gt(currentBidPrice)
-                    ? bestGenerator
-                    : currentGenerator;
-            });
-            if (!bestGenerator.next.done) {
-                // skip this node if it's already completely filled
-                if (bestGenerator.next.value.isBaseFilled()) {
-                    bestGenerator.next = bestGenerator.generator.next();
+                const bidOrder = bidNode.order;
+                const askOrder = askNode.order;
+                const bidUserAuthority = this.userMap.getUserAuthority(bidNode.userAccount.toString());
+                const askUserAuthority = this.userMap.getUserAuthority(askNode.userAccount.toString());
+                // Can't match orders from the same authority
+                const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+                if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
                     continue;
                 }
-                // skip order if user is being liquidated/bankrupt
-                if (bestGenerator.next.value.userAccount !== undefined) {
-                    const user = this.userMap.get(bestGenerator.next.value.userAccount.toString());
-                    if (user === null || user === void 0 ? void 0 : user.isBeingLiquidated()) {
-                        bestGenerator.next = bestGenerator.generator.next();
-                        continue;
-                    }
+                const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
+                const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
+                const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
+                const baseFilled = __1.BN.min(bidBaseRemaining, askBaseRemaining);
+                const newBidOrder = { ...bidOrder };
+                newBidOrder.baseAssetAmountFilled =
+                    bidOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
+                // ask completely filled
+                const newAskOrder = { ...askOrder };
+                newAskOrder.baseAssetAmountFilled =
+                    askOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
+                nodesToFill.push({
+                    node: takerNode,
+                    makerNode: makerNode,
+                });
+                if (newAskOrder.baseAssetAmount.eq(newAskOrder.baseAssetAmountFilled)) {
+                    break;
                 }
-                yield bestGenerator.next.value;
-                bestGenerator.next = bestGenerator.generator.next();
-            }
-            else {
-                bidsExhausted = true;
             }
         }
-    }
-    findCrossingOrders(askNode, bidNode, oraclePriceData, slot) {
-        const bidPrice = bidNode.getPrice(oraclePriceData, slot);
-        const askPrice = askNode.getPrice(oraclePriceData, slot);
-        // orders don't cross - we're done walkin gup the book
-        if (bidPrice.lt(askPrice)) {
-            return {
-                crossingNodes: [],
-                exhaustedSide: 'nocross',
-            };
-        }
-        const bidOrder = bidNode.order;
-        const askOrder = askNode.order;
-        const bidUserAuthority = this.userMap.getUserAuthority(bidNode.userAccount.toString());
-        const askUserAuthority = this.userMap.getUserAuthority(askNode.userAccount.toString());
-        // Can't match orders from the same authority
-        const sameAuthority = bidUserAuthority.equals(askUserAuthority);
-        if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
-            // don't have a principle way to pick which one to exhaust,
-            // exhaust each one 50% of the time so we can try each one against other orders
-            const exhaustedSide = Math.random() < 0.5 ? 'bid' : 'ask';
-            return {
-                crossingNodes: [],
-                exhaustedSide,
-            };
-        }
-        const { takerNode, makerNode, makerSide } = this.determineMakerAndTaker(askNode, bidNode);
-        // If maker is market order and auction is complete, cant be maker
-        if ((0, __1.isMarketOrder)(makerNode.order) &&
-            (0, __1.isAuctionComplete)(makerNode.order, slot)) {
-            return {
-                crossingNodes: [],
-                exhaustedSide: makerSide,
-            };
-        }
-        const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
-        const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
-        let exhaustedSide;
-        if (bidBaseRemaining.eq(askBaseRemaining)) {
-            exhaustedSide = 'both';
-        }
-        else if (bidBaseRemaining.gt(askBaseRemaining)) {
-            exhaustedSide = 'ask';
-        }
-        else {
-            exhaustedSide = 'bid';
-        }
-        // update the orders on DLOB as if they were fill - so we don't try to match them on the next iteration
-        // NOTE: if something goes wrong during the actual fill (transaction fails, i.e. due to orders already being filled)
-        // then we risk having a mismatch between this local DLOB and the actual DLOB state on the blockchain. This isn't
-        // a problem in the current implementation because we construct a new DLOB from the blockchain state every time, rather
-        // than updating the existing DLOB based on events.
-        if (exhaustedSide === 'ask') {
-            // bid partially filled
-            const newBidOrder = { ...bidOrder };
-            newBidOrder.baseAssetAmountFilled =
-                bidOrder.baseAssetAmountFilled.add(askBaseRemaining);
-            this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
-            // ask completely filled
-            const newAskOrder = { ...askOrder };
-            newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
-            this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
-        }
-        else if (exhaustedSide === 'bid') {
-            // ask partially filled
-            const newAskOrder = { ...askOrder };
-            newAskOrder.baseAssetAmountFilled =
-                askOrder.baseAssetAmountFilled.add(bidBaseRemaining);
-            this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
-            // bid completely filled
-            const newBidOrder = { ...bidOrder };
-            newBidOrder.baseAssetAmountFilled = bidOrder.baseAssetAmount;
-            this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
-        }
-        else {
-            // both completely filled
-            const newBidOrder = { ...bidOrder };
-            newBidOrder.baseAssetAmountFilled = bidOrder.baseAssetAmount;
-            this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
-            const newAskOrder = { ...askOrder };
-            newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
-            this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
-        }
-        return {
-            crossingNodes: [
-                {
-                    node: takerNode,
-                    makerNode: makerNode,
-                },
-            ],
-            exhaustedSide,
-        };
+        return nodesToFill;
     }
     determineMakerAndTaker(askNode, bidNode) {
         if (bidNode.order.postOnly) {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
-                makerSide: 'bid',
             };
         }
         else if (askNode.order.postOnly) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
-                makerSide: 'ask',
-            };
-        }
-        else if ((0, __1.isMarketOrder)(bidNode.order) && (0, __1.isLimitOrder)(askNode.order)) {
-            return {
-                takerNode: bidNode,
-                makerNode: askNode,
-                makerSide: 'ask',
-            };
-        }
-        else if ((0, __1.isMarketOrder)(askNode.order) && (0, __1.isLimitOrder)(bidNode.order)) {
-            return {
-                takerNode: askNode,
-                makerNode: bidNode,
-                makerSide: 'bid',
             };
         }
         else if (askNode.order.slot.lt(bidNode.order.slot)) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
-                makerSide: 'ask',
             };
         }
         else {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
-                makerSide: 'bid',
             };
         }
     }

package/lib/driftClient.d.ts

@@ -61,9 +61,23 @@ export declare class DriftClient {
     signerPublicKey?: PublicKey;
     getSignerPublicKey(): PublicKey;
     getStateAccount(): StateAccount;
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     */
+    forceGetStateAccount(): Promise<StateAccount>;
     getPerpMarketAccount(marketIndex: number): PerpMarketAccount | undefined;
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     * @param marketIndex
+     */
+    forceGetPerpMarketAccount(marketIndex: number): Promise<PerpMarketAccount | undefined>;
     getPerpMarketAccounts(): PerpMarketAccount[];
     getSpotMarketAccount(marketIndex: number): SpotMarketAccount | undefined;
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     * @param marketIndex
+     */
+    forceGetSpotMarketAccount(marketIndex: number): Promise<SpotMarketAccount | undefined>;
     getSpotMarketAccounts(): SpotMarketAccount[];
     getQuoteSpotMarketAccount(): SpotMarketAccount;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
@@ -94,6 +108,11 @@ export declare class DriftClient {
     getUserStatsAccountPublicKey(): PublicKey;
     getUserAccountPublicKey(): Promise<PublicKey>;
     getUserAccount(subAccountId?: number): UserAccount | undefined;
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     * @param subAccountId
+     */
+    forceGetUserAccount(subAccountId?: number): Promise<UserAccount | undefined>;
     getUserAccountAndSlot(subAccountId?: number): DataAndSlot<UserAccount> | undefined;
     getSpotPosition(marketIndex: number): SpotPosition | undefined;
     getQuoteAssetTokenAmount(): BN;