@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/lib/dlob/DLOB.js

@@ -0,0 +1,595 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOB = void 0;
+const NodeList_1 = require("./NodeList");
+const __1 = require("..");
+class DLOB {
+    /**
+     *
+     * @param perpMarkets The perp markets to maintain a DLOB for
+     * @param spotMarkets The spot markets to maintain a DLOB for
+     * @param silent set to true to prevent logging on inserts and removals
+     */
+    constructor(perpMarkets, spotMarkets, silent) {
+        this.openOrders = new Map();
+        this.orderLists = new Map();
+        this.marketIndexToAccount = new Map();
+        this.silent = false;
+        this.initialized = false;
+        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'),
+                },
+            });
+        }
+    }
+    /**
+     * initializes a new DLOB instance
+     *
+     * @param clearingHouse The ClearingHouse instance to use for price data
+     * @returns a promise that resolves when the DLOB is initialized
+     */
+    async init(clearingHouse, userMap) {
+        if (this.initialized) {
+            return false;
+        }
+        if (userMap) {
+            // initialize the dlob with the user map (prevents hitting getProgramAccounts)
+            for (const user of userMap.values()) {
+                const userAccount = user.getUserAccount();
+                const userAccountPubkey = user.getUserAccountPublicKey();
+                for (const order of userAccount.orders) {
+                    this.insertOrder(order, userAccountPubkey);
+                }
+            }
+        }
+        else {
+            const programAccounts = await clearingHouse.program.account.user.all();
+            for (const programAccount of programAccounts) {
+                // @ts-ignore
+                const userAccount = programAccount.account;
+                const userAccountPublicKey = programAccount.publicKey;
+                for (const order of userAccount.orders) {
+                    this.insertOrder(order, userAccountPublicKey);
+                }
+            }
+        }
+        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.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+            !order.triggered;
+        let type;
+        if (isInactiveTriggerOrder) {
+            type = 'trigger';
+        }
+        else if ((0, __1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+            type = 'market';
+        }
+        else if (!order.oraclePriceOffset.eq(__1.ZERO)) {
+            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, vBid, vAsk, slot, marketType, oraclePriceData) {
+        // Find all the crossing nodes
+        const crossingNodesToFill = this.findCrossingNodesToFill(marketIndex, slot, marketType, oraclePriceData);
+        const vAMMCrossingNodesToFill = this.findvAMMCrossingNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData);
+        // get expired market nodes
+        const marketNodesToFill = this.findExpiredMarketNodesToFill(marketIndex, slot, marketType);
+        return crossingNodesToFill.concat(vAMMCrossingNodesToFill, marketNodesToFill);
+    }
+    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;
+    }
+    findvAMMCrossingNodesToFill(marketIndex, vBid, vAsk, 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();
+        // check for asks that cross vBid
+        while (!nextAsk.done) {
+            const askNode = nextAsk.value;
+            const askPrice = askNode.getPrice(oraclePriceData, slot);
+            if (askPrice.lte(vBid) && (0, __1.isAuctionComplete)(askNode.order, slot)) {
+                nodesToFill.push({
+                    node: askNode,
+                    makerNode: undefined, // filled by vAMM
+                });
+            }
+            else {
+                break;
+            }
+            nextAsk = askGenerator.next();
+        }
+        // check for bids that cross vAsk
+        while (!nextBid.done) {
+            const bidNode = nextBid.value;
+            const bidPrice = bidNode.getPrice(oraclePriceData, slot);
+            if (bidPrice.gte(vAsk) && (0, __1.isAuctionComplete)(bidNode.order, slot)) {
+                nodesToFill.push({
+                    node: bidNode,
+                    makerNode: undefined, // filled by vAMM
+                });
+            }
+            else {
+                break;
+            }
+            nextBid = bidGenerator.next();
+        }
+        return nodesToFill;
+    }
+    findExpiredMarketNodesToFill(marketIndex, slot, marketType) {
+        const nodesToFill = new Array();
+        // Then see if there are orders to fill against vamm
+        for (const marketBid of this.getMarketBids(marketIndex, marketType)) {
+            if ((0, __1.isOrderExpired)(marketBid.order, slot)) {
+                nodesToFill.push({
+                    node: marketBid,
+                });
+            }
+        }
+        for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
+            if ((0, __1.isOrderExpired)(marketAsk.order, slot)) {
+                nodesToFill.push({
+                    node: marketAsk,
+                });
+            }
+        }
+        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, vAsk, 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' && vAsk) {
+            generatorList.push((0, NodeList_1.getVammNodeGenerator)(vAsk));
+        }
+        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;
+                }
+                yield bestGenerator.next.value;
+                bestGenerator.next = bestGenerator.generator.next();
+            }
+            else {
+                asksExhausted = true;
+            }
+        }
+    }
+    *getBids(marketIndex, vBid, 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' && vBid) {
+            generatorList.push((0, NodeList_1.getVammNodeGenerator)(vBid));
+        }
+        const bidGenerators = generatorList.map((generator) => {
+            return {
+                next: generator.next(),
+                generator,
+            };
+        });
+        let bidsExhausted = false; // there will always be the vBid
+        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;
+                }
+                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;
+        // Can't match two maker orders or if maker and taker are the same
+        const makerIsTaker = bidNode.userAccount.equals(askNode.userAccount);
+        if (makerIsTaker || (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 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);
+        }
+        // Bid is maker
+        if (bidOrder.postOnly) {
+            return {
+                crossingNodes: [
+                    {
+                        node: askNode,
+                        makerNode: bidNode,
+                    },
+                ],
+                exhaustedSide,
+            };
+        }
+        // Ask is maker
+        if (askOrder.postOnly) {
+            return {
+                crossingNodes: [
+                    {
+                        node: bidNode,
+                        makerNode: askNode,
+                    },
+                ],
+                exhaustedSide,
+            };
+        }
+        // Both are takers
+        // older order is maker
+        const [olderNode, newerNode] = askOrder.ts.lt(bidOrder.ts)
+            ? [askNode, bidNode]
+            : [bidNode, askNode];
+        return {
+            crossingNodes: [
+                {
+                    node: newerNode,
+                    makerNode: olderNode,
+                },
+            ],
+            exhaustedSide,
+        };
+    }
+    getBestAsk(marketIndex, vAsk, slot, marketType, oraclePriceData) {
+        return this.getAsks(marketIndex, vAsk, slot, marketType, oraclePriceData)
+            .next()
+            .value.getPrice(oraclePriceData, slot);
+    }
+    getBestBid(marketIndex, vBid, slot, marketType, oraclePriceData) {
+        return this.getBids(marketIndex, vBid, slot, marketType, oraclePriceData)
+            .next()
+            .value.getPrice(oraclePriceData, slot);
+    }
+    findNodesToTrigger(marketIndex, slot, oraclePrice, marketType) {
+        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, clearingHouse, slotSubscriber, marketIndex, marketType) {
+        if ((0, __1.isVariant)(marketType, 'perp')) {
+            const market = clearingHouse.getPerpMarketAccount(marketIndex);
+            const slot = slotSubscriber.getSlot();
+            const oraclePriceData = clearingHouse.getOracleDataForMarket(marketIndex);
+            const vAsk = (0, __1.calculateAskPrice)(market, oraclePriceData);
+            const vBid = (0, __1.calculateBidPrice)(market, oraclePriceData);
+            const bestAsk = this.getBestAsk(marketIndex, vAsk, slot, marketType, oraclePriceData);
+            const bestBid = this.getBestBid(marketIndex, vBid, 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 = clearingHouse.getOracleDataForMarket(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;

package/lib/dlob/DLOBNode.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="bn.js" />
+import { BN, SpotMarketAccount, PerpMarketAccount, OraclePriceData, Order } from '..';
+import { PublicKey } from '@solana/web3.js';
+export interface DLOBNode {
+    getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+    isVammNode(): boolean;
+    order: Order | undefined;
+    isBaseFilled(): boolean;
+    haveFilled: boolean;
+    userAccount: PublicKey | undefined;
+    market: SpotMarketAccount | PerpMarketAccount;
+}
+export declare abstract class OrderNode implements DLOBNode {
+    order: Order;
+    market: SpotMarketAccount | PerpMarketAccount;
+    userAccount: PublicKey;
+    sortValue: BN;
+    haveFilled: boolean;
+    haveTrigger: boolean;
+    constructor(order: Order, market: SpotMarketAccount | PerpMarketAccount, userAccount: PublicKey);
+    abstract getSortValue(order: Order): BN;
+    getLabel(): string;
+    getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+    isBaseFilled(): boolean;
+    isVammNode(): boolean;
+}
+export declare class LimitOrderNode extends OrderNode {
+    next?: LimitOrderNode;
+    previous?: LimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class FloatingLimitOrderNode extends OrderNode {
+    next?: FloatingLimitOrderNode;
+    previous?: FloatingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class MarketOrderNode extends OrderNode {
+    next?: MarketOrderNode;
+    previous?: MarketOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class TriggerOrderNode extends OrderNode {
+    next?: TriggerOrderNode;
+    previous?: TriggerOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare type DLOBNodeMap = {
+    limit: LimitOrderNode;
+    floatingLimit: FloatingLimitOrderNode;
+    market: MarketOrderNode;
+    trigger: TriggerOrderNode;
+};
+export declare type DLOBNodeType = 'limit' | 'floatingLimit' | 'market' | ('trigger' & keyof DLOBNodeMap);
+export declare function createNode<T extends DLOBNodeType>(nodeType: T, order: Order, market: SpotMarketAccount | PerpMarketAccount, userAccount: PublicKey): DLOBNodeMap[T];