@drift-labs/sdk 2.0.12 → 2.0.14

package/lib/dlob/DLOB.d.ts

@@ -57,15 +57,20 @@ export declare class DLOB {
     trigger(order: Order, userAccount: PublicKey, onTrigger?: OrderBookCallback): void;
     getListForOrder(order: Order): NodeList<any> | undefined;
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
-    findCrossingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
-    findFallbackCrossingNodesToFill(marketIndex: number, fallbackBid: BN, fallbackAsk: BN, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): 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(slot: number, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGenerator: Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): 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[];
     getMarketBids(marketIndex: number, marketType: MarketType): Generator<DLOBNode>;
     getMarketAsks(marketIndex: number, marketType: MarketType): Generator<DLOBNode>;
+    private getBestNode;
+    getLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    getLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): 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>;
-    findCrossingOrders(askNode: DLOBNode, bidNode: DLOBNode, oraclePriceData: OraclePriceData, slot: number): {
+    findCrossingLimitOrders(askNode: DLOBNode, bidNode: DLOBNode, oraclePriceData: OraclePriceData, slot: number): {
         crossingNodes: NodeToFill[];
         exhaustedSide: Side;
     };

package/lib/dlob/DLOB.js

@@ -180,27 +180,22 @@ 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 askGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
+        let bidGenerator = this.getLimitBids(marketIndex, 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);
+            const { crossingNodes, exhaustedSide } = this.findCrossingLimitOrders(nextAsk.value, nextBid.value, oraclePriceData, slot);
             if (exhaustedSide === 'bid') {
                 nextBid = bidGenerator.next();
             }
@@ -222,56 +217,141 @@ class DLOB {
                 nodesToFill.push(crossingNode);
             }
         }
+        if (fallbackBid && !isAmmPaused) {
+            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);
+            }
+        }
+        if (fallbackAsk && !isAmmPaused) {
+            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);
+            }
+        }
         return nodesToFill;
     }
-    findFallbackCrossingNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, marketType, oraclePriceData) {
-        var _a, _b;
+    findMarketNodesToFill(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();
-        // 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();
+        let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
+        let limitOrderGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
+        const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(slot, oraclePriceData, marketOrderGenerator, limitOrderGenerator, (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);
+            }
+        }
+        marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
+        limitOrderGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
+        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(slot, oraclePriceData, marketOrderGenerator, limitOrderGenerator, (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;
+    }
+    findMarketNodesCrossingLimitNodes(slot, oraclePriceData, takerNodeGenerator, makerNodeGenerator, doesCross) {
+        const nodesToFill = new Array();
+        let nextTakerNode = takerNodeGenerator.next();
+        let nextMakerNode = makerNodeGenerator.next();
+        while (!nextTakerNode.done && !nextMakerNode.done) {
+            const takerNode = nextTakerNode.value;
+            const makerNode = nextMakerNode.value;
+            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) {
+                if (Math.random() < 0.5) {
+                    nextTakerNode = takerNodeGenerator.next();
+                }
+                else {
+                    nextMakerNode = makerNodeGenerator.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) {
-                nodesToFill.push({
-                    node: askNode,
-                    makerNode: undefined, // filled by fallback
-                });
+            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
+                nextTakerNode = takerNodeGenerator.next();
+                continue;
+            }
+            nodesToFill.push({
+                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);
+            if (newMakerOrder.baseAssetAmountFilled.eq(makerOrder.baseAssetAmount)) {
+                nextMakerNode = makerNodeGenerator.next();
+            }
+            const newTakerOrder = { ...takerOrder };
+            newTakerOrder.baseAssetAmountFilled =
+                takerOrder.baseAssetAmountFilled.add(baseFilled);
+            this.getListForOrder(newTakerOrder).update(newTakerOrder, takerNode.userAccount);
+            if (newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)) {
+                nextTakerNode = takerNodeGenerator.next();
             }
-            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 +409,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 +484,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,58 +511,44 @@ class DLOB {
         const generatorList = [
             nodeLists.limit.bid.getGenerator(),
             nodeLists.floatingLimit.bid.getGenerator(),
-            nodeLists.market.bid.getGenerator(),
         ];
-        if (marketTypeStr === 'perp' && fallbackBid) {
-            generatorList.push((0, NodeList_1.getVammNodeGenerator)(fallbackBid));
+        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');
         }
-        if (generatorList.length === 0) {
-            throw new Error('No bid generators found');
+        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));
         }
-        const bidGenerators = generatorList.map((generator) => {
-            return {
-                next: generator.next(),
-                generator,
-            };
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
+            return bestPrice.lt(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;
-                }
-                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();
-                    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;
-                    }
-                }
-                yield bestGenerator.next.value;
-                bestGenerator.next = bestGenerator.generator.next();
-            }
-            else {
-                bidsExhausted = true;
-            }
+    }
+    *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));
+        }
+        yield* this.getBestNode(generatorList, oraclePriceData, slot, (bestPrice, currentPrice) => {
+            return bestPrice.gt(currentPrice);
+        });
     }
-    findCrossingOrders(askNode, bidNode, oraclePriceData, slot) {
+    findCrossingLimitOrders(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
@@ -488,15 +573,7 @@ class DLOB {
                 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 { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
         const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
         const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
         let exhaustedSide;
@@ -570,20 +647,6 @@ class DLOB {
                 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,

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;

package/lib/driftClient.js

@@ -177,10 +177,26 @@ class DriftClient {
     getStateAccount() {
         return this.accountSubscriber.getStateAccountAndSlot().data;
     }
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     */
+    async forceGetStateAccount() {
+        await this.accountSubscriber.fetch();
+        return this.accountSubscriber.getStateAccountAndSlot().data;
+    }
     getPerpMarketAccount(marketIndex) {
         var _a;
         return (_a = this.accountSubscriber.getMarketAccountAndSlot(marketIndex)) === null || _a === void 0 ? void 0 : _a.data;
     }
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     * @param marketIndex
+     */
+    async forceGetPerpMarketAccount(marketIndex) {
+        var _a;
+        await this.accountSubscriber.fetch();
+        return (_a = this.accountSubscriber.getMarketAccountAndSlot(marketIndex)) === null || _a === void 0 ? void 0 : _a.data;
+    }
     getPerpMarketAccounts() {
         return this.accountSubscriber
             .getMarketAccountsAndSlots()
@@ -189,6 +205,14 @@ class DriftClient {
     getSpotMarketAccount(marketIndex) {
         return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
     }
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     * @param marketIndex
+     */
+    async forceGetSpotMarketAccount(marketIndex) {
+        await this.accountSubscriber.fetch();
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
+    }
     getSpotMarketAccounts() {
         return this.accountSubscriber
             .getSpotMarketAccountsAndSlots()
@@ -414,6 +438,14 @@ class DriftClient {
     getUserAccount(subAccountId) {
         return this.getUser(subAccountId).getUserAccount();
     }
+    /**
+     * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
+     * @param subAccountId
+     */
+    async forceGetUserAccount(subAccountId) {
+        await this.getUser(subAccountId).fetchAccounts();
+        return this.getUser(subAccountId).getUserAccount();
+    }
     getUserAccountAndSlot(subAccountId) {
         return this.getUser(subAccountId).getUserAccountAndSlot();
     }

package/lib/math/orders.d.ts

@@ -7,8 +7,7 @@ export declare function isOrderRiskIncreasing(user: User, order: Order): boolean
 export declare function isOrderRiskIncreasingInSameDirection(user: User, order: Order): boolean;
 export declare function isOrderReduceOnly(user: User, order: Order): boolean;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
-export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;
-export declare function getOptionalLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN | undefined;
+export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number, fallbackPrice?: BN): BN | undefined;
 export declare function hasLimitPrice(order: Order, slot: number): boolean;
 export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, ts: number): boolean;
 export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;

package/lib/math/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTriggered = exports.mustBeTriggered = exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasLimitPrice = exports.getOptionalLimitPrice = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.isTriggered = exports.mustBeTriggered = exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasLimitPrice = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
@@ -79,7 +79,7 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
     return baseAssetAmount.sub(remainder);
 }
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, oraclePriceData, slot) {
+function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
     let limitPrice;
     if (order.oraclePriceOffset !== 0) {
         limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
@@ -92,14 +92,7 @@ function getLimitPrice(order, oraclePriceData, slot) {
             limitPrice = order.price;
         }
         else {
-            // check oracle validity?
-            const oraclePrice1Pct = oraclePriceData.price.div(new anchor_1.BN(100));
-            if ((0, types_1.isVariant)(order.direction, 'long')) {
-                limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
-            }
-            else {
-                limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
-            }
+            limitPrice = fallbackPrice;
         }
     }
     else {
@@ -108,15 +101,6 @@ function getLimitPrice(order, oraclePriceData, slot) {
     return limitPrice;
 }
 exports.getLimitPrice = getLimitPrice;
-function getOptionalLimitPrice(order, oraclePriceData, slot) {
-    if (hasLimitPrice(order, slot)) {
-        return getLimitPrice(order, oraclePriceData, slot);
-    }
-    else {
-        return undefined;
-    }
-}
-exports.getOptionalLimitPrice = getOptionalLimitPrice;
 function hasLimitPrice(order, slot) {
     return (order.price.gt(numericConstants_1.ZERO) ||
         order.oraclePriceOffset != 0 ||
@@ -133,7 +117,7 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData,
     if (mustBeTriggered(order) && !isTriggered(order)) {
         return numericConstants_1.ZERO;
     }
-    const limitPrice = getOptionalLimitPrice(order, oraclePriceData, slot);
+    const limitPrice = getLimitPrice(order, oraclePriceData, slot);
     let baseAssetAmount;
     const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
     if (limitPrice !== undefined) {