@drift-labs/sdk 0.2.0-temp.1 → 2.0.0

package/lib/dlob/DLOB.js

@@ -0,0 +1,694 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOB = void 0;
+const NodeList_1 = require("./NodeList");
+const __1 = require("..");
+const exchangeStatus_1 = require("../math/exchangeStatus");
+class DLOB {
+    /**
+     *
+     * @param perpMarkets The perp markets to maintain a DLOB for
+     * @param spotMarkets The spot markets to maintain a DLOB for
+     * @param userMap map of all users
+     * @param silent set to true to prevent logging on inserts and removals
+     */
+    constructor(perpMarkets, spotMarkets, stateAccount, userMap, silent) {
+        this.openOrders = new Map();
+        this.orderLists = new Map();
+        this.marketIndexToAccount = new Map();
+        this.silent = false;
+        this.initialized = false;
+        this.stateAccount = stateAccount;
+        this.userMap = userMap;
+        this.silent = silent;
+        this.openOrders.set('perp', new Set());
+        this.openOrders.set('spot', new Set());
+        this.orderLists.set('perp', new Map());
+        this.orderLists.set('spot', new Map());
+        this.marketIndexToAccount.set('perp', new Map());
+        this.marketIndexToAccount.set('spot', new Map());
+        for (const market of perpMarkets) {
+            const marketIndex = market.marketIndex;
+            this.marketIndexToAccount.get('perp').set(marketIndex, market);
+            this.orderLists.get('perp').set(marketIndex, {
+                limit: {
+                    ask: new NodeList_1.NodeList('limit', 'asc'),
+                    bid: new NodeList_1.NodeList('limit', 'desc'),
+                },
+                floatingLimit: {
+                    ask: new NodeList_1.NodeList('floatingLimit', 'asc'),
+                    bid: new NodeList_1.NodeList('floatingLimit', 'desc'),
+                },
+                market: {
+                    ask: new NodeList_1.NodeList('market', 'asc'),
+                    bid: new NodeList_1.NodeList('market', 'asc'), // always sort ascending for market orders
+                },
+                trigger: {
+                    above: new NodeList_1.NodeList('trigger', 'asc'),
+                    below: new NodeList_1.NodeList('trigger', 'desc'),
+                },
+            });
+        }
+        for (const market of spotMarkets) {
+            const marketIndex = market.marketIndex;
+            this.marketIndexToAccount.get('spot').set(marketIndex, market);
+            this.orderLists.get('spot').set(marketIndex, {
+                limit: {
+                    ask: new NodeList_1.NodeList('limit', 'asc'),
+                    bid: new NodeList_1.NodeList('limit', 'desc'),
+                },
+                floatingLimit: {
+                    ask: new NodeList_1.NodeList('floatingLimit', 'asc'),
+                    bid: new NodeList_1.NodeList('floatingLimit', 'desc'),
+                },
+                market: {
+                    ask: new NodeList_1.NodeList('market', 'asc'),
+                    bid: new NodeList_1.NodeList('market', 'asc'), // always sort ascending for market orders
+                },
+                trigger: {
+                    above: new NodeList_1.NodeList('trigger', 'asc'),
+                    below: new NodeList_1.NodeList('trigger', 'desc'),
+                },
+            });
+        }
+    }
+    clear() {
+        for (const marketType of this.openOrders.keys()) {
+            this.openOrders.get(marketType).clear();
+        }
+        this.openOrders.clear();
+        for (const marketType of this.orderLists.keys()) {
+            for (const marketIndex of this.orderLists.get(marketType).keys()) {
+                const marketNodeLists = this.orderLists
+                    .get(marketType)
+                    .get(marketIndex);
+                for (const side of Object.keys(marketNodeLists)) {
+                    for (const orderType of Object.keys(marketNodeLists[side])) {
+                        marketNodeLists[side][orderType].clear();
+                    }
+                }
+            }
+        }
+        this.orderLists.clear();
+        for (const marketType of this.marketIndexToAccount.keys()) {
+            this.marketIndexToAccount.get(marketType).clear();
+        }
+        this.marketIndexToAccount.clear();
+    }
+    /**
+     * initializes a new DLOB instance
+     *
+     * @returns a promise that resolves when the DLOB is initialized
+     */
+    async init() {
+        if (this.initialized) {
+            return false;
+        }
+        // initialize the dlob with the user map (prevents hitting getProgramAccounts)
+        for (const user of this.userMap.values()) {
+            const userAccount = user.getUserAccount();
+            const userAccountPubkey = user.getUserAccountPublicKey();
+            for (const order of userAccount.orders) {
+                this.insertOrder(order, userAccountPubkey);
+            }
+        }
+        this.initialized = true;
+        return true;
+    }
+    insertOrder(order, userAccount, onInsert) {
+        var _a;
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        const marketType = (0, __1.getVariant)(order.marketType);
+        if ((0, __1.isVariant)(order.status, 'open')) {
+            this.openOrders
+                .get(marketType)
+                .add((0, NodeList_1.getOrderSignature)(order.orderId, userAccount));
+        }
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, this.marketIndexToAccount.get(marketType).get(order.marketIndex), userAccount);
+        if (onInsert) {
+            onInsert();
+        }
+    }
+    trigger(order, userAccount, onTrigger) {
+        var _a;
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        const marketType = (0, __1.getVariant)(order.marketType);
+        const triggerList = this.orderLists.get(marketType).get(order.marketIndex)
+            .trigger[(0, __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, this.marketIndexToAccount.get(marketType).get(order.marketIndex), userAccount);
+        if (onTrigger) {
+            onTrigger();
+        }
+    }
+    getListForOrder(order) {
+        const isInactiveTriggerOrder = (0, __1.mustBeTriggered)(order) && !(0, __1.isTriggered)(order);
+        let type;
+        if (isInactiveTriggerOrder) {
+            type = 'trigger';
+        }
+        else if ((0, __1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+            type = 'market';
+        }
+        else if (order.oraclePriceOffset !== 0) {
+            type = 'floatingLimit';
+        }
+        else {
+            type = 'limit';
+        }
+        let subType;
+        if (isInactiveTriggerOrder) {
+            subType = (0, __1.isVariant)(order.triggerCondition, 'above') ? 'above' : 'below';
+        }
+        else {
+            subType = (0, __1.isVariant)(order.direction, 'long') ? 'bid' : 'ask';
+        }
+        const marketType = (0, __1.getVariant)(order.marketType);
+        if (!this.orderLists.has(marketType)) {
+            return undefined;
+        }
+        return this.orderLists.get(marketType).get(order.marketIndex)[type][subType];
+    }
+    findNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, ts, marketType, oraclePriceData) {
+        const marketAccount = this.marketIndexToAccount
+            .get((0, __1.getVariant)(marketType))
+            .get(marketIndex);
+        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);
+        }
+        // get expired market nodes
+        const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
+        return crossingNodesToFill.concat(fallbackCrossingNodesToFill, expiredNodesToFill);
+    }
+    findCrossingNodesToFill(marketIndex, slot, marketType, oraclePriceData) {
+        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();
+            }
+            else if (exhaustedSide === 'nocross') {
+                break;
+            }
+            else {
+                console.error(`invalid exhaustedSide: ${exhaustedSide}`);
+                break;
+            }
+            for (const crossingNode of crossingNodes) {
+                nodesToFill.push(crossingNode);
+            }
+        }
+        return nodesToFill;
+    }
+    findFallbackCrossingNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, marketType, oraclePriceData) {
+        var _a, _b;
+        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) {
+                nodesToFill.push({
+                    node: askNode,
+                    makerNode: undefined, // filled by fallback
+                });
+            }
+            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();
+                continue;
+            }
+            const bidLimitPrice = (0, __1.getOptionalLimitPrice)(bidNode.order, oraclePriceData, slot);
+            // order crosses if there is no limit price or it crosses fallback price
+            const crosses = bidLimitPrice === undefined || bidLimitPrice.gte(fallbackAsk);
+            // 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);
+            if (crosses && fallbackAvailable) {
+                nodesToFill.push({
+                    node: bidNode,
+                    makerNode: undefined, // filled by fallback
+                });
+            }
+            nextBid = bidGenerator.next();
+        }
+        return nodesToFill;
+    }
+    findExpiredNodesToFill(marketIndex, ts, marketType) {
+        const nodesToFill = new Array();
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        // All bids/asks that can expire
+        const bidGenerators = [
+            nodeLists.limit.bid.getGenerator(),
+            nodeLists.floatingLimit.bid.getGenerator(),
+            nodeLists.market.bid.getGenerator(),
+        ];
+        const askGenerators = [
+            nodeLists.limit.ask.getGenerator(),
+            nodeLists.floatingLimit.ask.getGenerator(),
+            nodeLists.market.ask.getGenerator(),
+        ];
+        for (const bidGenerator of bidGenerators) {
+            for (const bid of bidGenerator) {
+                if ((0, __1.isOrderExpired)(bid.order, ts)) {
+                    nodesToFill.push({
+                        node: bid,
+                    });
+                }
+            }
+        }
+        for (const askGenerator of askGenerators) {
+            for (const ask of askGenerator) {
+                if ((0, __1.isOrderExpired)(ask.order, ts)) {
+                    nodesToFill.push({
+                        node: ask,
+                    });
+                }
+            }
+        }
+        return nodesToFill;
+    }
+    findJitAuctionNodesToFill(marketIndex, slot, marketType) {
+        const nodesToFill = new Array();
+        // Then see if there are orders still in JIT auction
+        for (const marketBid of this.getMarketBids(marketIndex, marketType)) {
+            if (!(0, __1.isAuctionComplete)(marketBid.order, slot)) {
+                nodesToFill.push({
+                    node: marketBid,
+                });
+            }
+        }
+        for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
+            if (!(0, __1.isAuctionComplete)(marketAsk.order, slot)) {
+                nodesToFill.push({
+                    node: marketAsk,
+                });
+            }
+        }
+        return nodesToFill;
+    }
+    getMarketBids(marketIndex, marketType) {
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        return this.orderLists
+            .get(marketTypeStr)
+            .get(marketIndex)
+            .market.bid.getGenerator();
+    }
+    getMarketAsks(marketIndex, marketType) {
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        return 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');
+        }
+        const askGenerators = generatorList.map((generator) => {
+            return {
+                next: generator.next(),
+                generator,
+            };
+        });
+        let asksExhausted = false;
+        while (!asksExhausted) {
+            const bestGenerator = askGenerators.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)
+                    ? 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 {
+                asksExhausted = 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 marketTypeStr = (0, __1.getVariant)(marketType);
+        const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        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));
+        }
+        if (generatorList.length === 0) {
+            throw new Error('No bid generators found');
+        }
+        const bidGenerators = generatorList.map((generator) => {
+            return {
+                next: generator.next(),
+                generator,
+            };
+        });
+        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;
+            }
+        }
+    }
+    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,
+        };
+    }
+    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',
+            };
+        }
+    }
+    getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
+        return this.getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData)
+            .next()
+            .value.getPrice(oraclePriceData, slot);
+    }
+    getBestBid(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
+        return this.getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData)
+            .next()
+            .value.getPrice(oraclePriceData, slot);
+    }
+    findNodesToTrigger(marketIndex, slot, oraclePrice, marketType) {
+        if ((0, exchangeStatus_1.exchangePaused)(this.stateAccount)) {
+            return [];
+        }
+        const nodesToTrigger = [];
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        for (const node of this.orderLists
+            .get(marketTypeStr)
+            .get(marketIndex)
+            .trigger.above.getGenerator()) {
+            if (oraclePrice.gt(node.order.triggerPrice)) {
+                if ((0, __1.isAuctionComplete)(node.order, slot)) {
+                    nodesToTrigger.push({
+                        node: node,
+                    });
+                }
+            }
+            else {
+                break;
+            }
+        }
+        for (const node of this.orderLists
+            .get(marketTypeStr)
+            .get(marketIndex)
+            .trigger.below.getGenerator()) {
+            if (oraclePrice.lt(node.order.triggerPrice)) {
+                if ((0, __1.isAuctionComplete)(node.order, slot)) {
+                    nodesToTrigger.push({
+                        node: node,
+                    });
+                }
+            }
+            else {
+                break;
+            }
+        }
+        return nodesToTrigger;
+    }
+    printTopOfOrderLists(sdkConfig, driftClient, slotSubscriber, marketIndex, marketType) {
+        if ((0, __1.isVariant)(marketType, 'perp')) {
+            const market = driftClient.getPerpMarketAccount(marketIndex);
+            const slot = slotSubscriber.getSlot();
+            const oraclePriceData = driftClient.getOracleDataForPerpMarket(marketIndex);
+            const fallbackAsk = (0, __1.calculateAskPrice)(market, oraclePriceData);
+            const fallbackBid = (0, __1.calculateBidPrice)(market, oraclePriceData);
+            const bestAsk = this.getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData);
+            const bestBid = this.getBestBid(marketIndex, fallbackBid, slot, marketType, oraclePriceData);
+            const mid = bestAsk.add(bestBid).div(new __1.BN(2));
+            const bidSpread = ((0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
+                1) *
+                100.0;
+            const askSpread = ((0, __1.convertToNumber)(bestAsk, __1.PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
+                1) *
+                100.0;
+            console.log(`Market ${sdkConfig.MARKETS[marketIndex].symbol} Orders`);
+            console.log(`  Ask`, (0, __1.convertToNumber)(bestAsk, __1.PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
+            console.log(`  Mid`, (0, __1.convertToNumber)(mid, __1.PRICE_PRECISION).toFixed(3));
+            console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION).toFixed(3), `(${bidSpread.toFixed(4)}%)`);
+        }
+        else if ((0, __1.isVariant)(marketType, 'spot')) {
+            const slot = slotSubscriber.getSlot();
+            const oraclePriceData = driftClient.getOracleDataForPerpMarket(marketIndex);
+            const bestAsk = this.getBestAsk(marketIndex, undefined, slot, marketType, oraclePriceData);
+            const bestBid = this.getBestBid(marketIndex, undefined, slot, marketType, oraclePriceData);
+            const mid = bestAsk.add(bestBid).div(new __1.BN(2));
+            const bidSpread = ((0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
+                1) *
+                100.0;
+            const askSpread = ((0, __1.convertToNumber)(bestAsk, __1.PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
+                1) *
+                100.0;
+            console.log(`Market ${sdkConfig.MARKETS[marketIndex].symbol} Orders`);
+            console.log(`  Ask`, (0, __1.convertToNumber)(bestAsk, __1.PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
+            console.log(`  Mid`, (0, __1.convertToNumber)(mid, __1.PRICE_PRECISION).toFixed(3));
+            console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION).toFixed(3), `(${bidSpread.toFixed(4)}%)`);
+        }
+    }
+}
+exports.DLOB = DLOB;