@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

package/lib/dlob/DLOB.js

@@ -0,0 +1,557 @@
+"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.toNumber(), market);
+            this.orderLists.get('perp').set(marketIndex.toNumber(), {
+                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.toNumber(), market);
+            this.orderLists.get('spot').set(marketIndex.toNumber(), {
+                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) {
+        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));
+        }
+        this.getListForOrder(order).insert(order, marketType, this.marketIndexToAccount
+            .get(marketType)
+            .get(order.marketIndex.toNumber()), userAccount);
+        if (onInsert) {
+            onInsert();
+        }
+    }
+    trigger(order, userAccount, onTrigger) {
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        const marketType = (0, __1.getVariant)(order.marketType);
+        const triggerList = this.orderLists
+            .get(marketType)
+            .get(order.marketIndex.toNumber()).trigger[(0, __1.isVariant)(order.triggerCondition, 'above') ? 'above' : 'below'];
+        triggerList.remove(order, userAccount);
+        this.getListForOrder(order).insert(order, marketType, this.marketIndexToAccount
+            .get(marketType)
+            .get(order.marketIndex.toNumber()), 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.gt(__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);
+        return this.orderLists.get(marketType).get(order.marketIndex.toNumber())[type][subType];
+    }
+    findNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData) {
+        // Find all the crossing nodes
+        const crossingNodesToFill = this.findCrossingNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData);
+        // get expired market nodes
+        const marketNodesToFill = this.findMarketNodesToFill(marketIndex, slot, marketType);
+        return crossingNodesToFill.concat(marketNodesToFill);
+    }
+    findCrossingNodesToFill(marketIndex, vBid, vAsk, slot, marketType, oraclePriceData) {
+        const nodesToFill = new Array();
+        const askGenerator = this.getAsks(marketIndex, vAsk, slot, marketType, oraclePriceData);
+        const bidGenerator = this.getBids(marketIndex, 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 {
+                console.error(`invalid exhaustedSide: ${exhaustedSide}`);
+                break;
+            }
+            const takerIsMaker = (crossingNodes === null || crossingNodes === void 0 ? void 0 : crossingNodes.makerNode) !== undefined &&
+                crossingNodes.node.userAccount.equals(crossingNodes.makerNode.userAccount);
+            // Verify that each side is different user
+            if (crossingNodes && !takerIsMaker) {
+                nodesToFill.push(crossingNodes);
+            }
+        }
+        return nodesToFill;
+    }
+    findMarketNodesToFill(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.isAuctionComplete)(marketBid.order, slot) ||
+                (0, __1.isOrderExpired)(marketBid.order, slot)) {
+                nodesToFill.push({
+                    node: marketBid,
+                });
+            }
+        }
+        for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
+            if ((0, __1.isAuctionComplete)(marketAsk.order, slot) ||
+                (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.toNumber())
+            .market.bid.getGenerator();
+    }
+    getMarketAsks(marketIndex, marketType) {
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        return this.orderLists
+            .get(marketTypeStr)
+            .get(marketIndex.toNumber())
+            .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.toNumber());
+        const generatorList = [
+            nodeLists.limit.ask.getGenerator(),
+            nodeLists.floatingLimit.ask.getGenerator(),
+            nodeLists.market.ask.getGenerator(),
+        ];
+        if (marketTypeStr === 'perp') {
+            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) {
+                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.toNumber());
+        const generatorList = [
+            nodeLists.limit.bid.getGenerator(),
+            nodeLists.floatingLimit.bid.getGenerator(),
+            nodeLists.market.bid.getGenerator(),
+        ];
+        if (marketTypeStr === 'perp') {
+            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) {
+                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);
+        const bidOrder = bidNode.order;
+        const askOrder = askNode.order;
+        const containsMarketOrder = (askOrder && (0, __1.isVariant)(askOrder.orderType, 'market')) ||
+            (bidOrder && (0, __1.isVariant)(bidOrder.orderType, 'market'));
+        if (!containsMarketOrder || bidPrice.lt(askPrice)) {
+            // no market orders, and no crossing orders - return
+            if (askNode.isVammNode() && !bidNode.isVammNode()) {
+                return {
+                    exhaustedSide: 'bid',
+                };
+            }
+            else if (!askNode.isVammNode() && bidNode.isVammNode()) {
+                return {
+                    exhaustedSide: 'ask',
+                };
+            }
+            else {
+                return {
+                    exhaustedSide: 'both',
+                };
+            }
+        }
+        // User bid crosses the vamm ask
+        if (askNode.isVammNode()) {
+            if (!(0, __1.isAuctionComplete)(bidOrder, slot)) {
+                return {
+                    exhaustedSide: 'bid',
+                };
+            }
+            return {
+                crossingNodes: {
+                    node: bidNode,
+                },
+                exhaustedSide: 'bid',
+            };
+        }
+        // User ask crosses the vamm bid
+        if (bidNode.isVammNode()) {
+            if (!(0, __1.isAuctionComplete)(askOrder, slot)) {
+                return {
+                    exhaustedSide: 'ask',
+                };
+            }
+            return {
+                crossingNodes: {
+                    node: askNode,
+                },
+                exhaustedSide: 'ask',
+            };
+        }
+        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';
+        }
+        // Can't match two maker orders
+        if (bidOrder.postOnly && askOrder.postOnly) {
+            return {
+                exhaustedSide,
+            };
+        }
+        // update the orders as if they fill - so we don't try to match them on the next iteration
+        if (exhaustedSide === 'ask') {
+            bidNode.order.baseAssetAmountFilled =
+                bidOrder.baseAssetAmountFilled.add(askBaseRemaining);
+            askNode.order.baseAssetAmountFilled = askOrder.baseAssetAmount;
+        }
+        else if (exhaustedSide === 'bid') {
+            askNode.order.baseAssetAmountFilled =
+                askOrder.baseAssetAmountFilled.add(bidBaseRemaining);
+            bidNode.order.baseAssetAmountFilled = bidOrder.baseAssetAmount;
+        }
+        else {
+            askNode.order.baseAssetAmountFilled = askOrder.baseAssetAmount;
+            bidNode.order.baseAssetAmountFilled = bidOrder.baseAssetAmount;
+        }
+        // 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.toNumber())
+            .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.toNumber())
+            .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.MARK_PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.MARK_PRICE_PRECISION) -
+                1) *
+                100.0;
+            const askSpread = ((0, __1.convertToNumber)(bestAsk, __1.MARK_PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.MARK_PRICE_PRECISION) -
+                1) *
+                100.0;
+            console.log(`Market ${sdkConfig.MARKETS[marketIndex.toNumber()].symbol} Orders`);
+            console.log(`  Ask`, (0, __1.convertToNumber)(bestAsk, __1.MARK_PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
+            console.log(`  Mid`, (0, __1.convertToNumber)(mid, __1.MARK_PRICE_PRECISION).toFixed(3));
+            console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.MARK_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.MARK_PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.MARK_PRICE_PRECISION) -
+                1) *
+                100.0;
+            const askSpread = ((0, __1.convertToNumber)(bestAsk, __1.MARK_PRICE_PRECISION) /
+                (0, __1.convertToNumber)(oraclePriceData.price, __1.MARK_PRICE_PRECISION) -
+                1) *
+                100.0;
+            console.log(`Market ${sdkConfig.MARKETS[marketIndex.toNumber()].symbol} Orders`);
+            console.log(`  Ask`, (0, __1.convertToNumber)(bestAsk, __1.MARK_PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
+            console.log(`  Mid`, (0, __1.convertToNumber)(mid, __1.MARK_PRICE_PRECISION).toFixed(3));
+            console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.MARK_PRICE_PRECISION).toFixed(3), `(${bidSpread.toFixed(4)}%)`);
+        }
+    }
+}
+exports.DLOB = DLOB;

package/lib/dlob/DLOBNode.d.ts

@@ -0,0 +1,52 @@
+/// <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;
+    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;
+    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];

package/lib/dlob/DLOBNode.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNode = exports.TriggerOrderNode = exports.MarketOrderNode = exports.FloatingLimitOrderNode = exports.LimitOrderNode = exports.OrderNode = void 0;
+const __1 = require("..");
+const NodeList_1 = require("./NodeList");
+class OrderNode {
+    constructor(order, market, userAccount) {
+        this.haveFilled = false;
+        this.haveTrigger = false;
+        this.order = order;
+        this.market = market;
+        this.userAccount = userAccount;
+        this.sortValue = this.getSortValue(order);
+    }
+    getLabel() {
+        let msg = `Order ${(0, NodeList_1.getOrderSignature)(this.order.orderId, this.userAccount)}`;
+        msg += ` ${(0, __1.isVariant)(this.order.direction, 'long') ? 'LONG' : 'SHORT'} `;
+        msg += `${(0, __1.convertToNumber)(this.order.baseAssetAmount, __1.AMM_RESERVE_PRECISION).toFixed(3)}`;
+        if (this.order.price.gt(__1.ZERO)) {
+            msg += ` @ ${(0, __1.convertToNumber)(this.order.price, __1.MARK_PRICE_PRECISION).toFixed(3)}`;
+        }
+        if (this.order.triggerPrice.gt(__1.ZERO)) {
+            msg += ` ${(0, __1.isVariant)(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'}`;
+            msg += ` ${(0, __1.convertToNumber)(this.order.triggerPrice, __1.MARK_PRICE_PRECISION).toFixed(3)}`;
+        }
+        return msg;
+    }
+    getPrice(oraclePriceData, slot) {
+        if ((0, __1.isOneOfVariant)(this.order.marketType, ['spot'])) {
+            return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot);
+        }
+        else if ((0, __1.isOneOfVariant)(this.order.marketType, ['perp'])) {
+            return (0, __1.getLimitPrice)(this.order, oraclePriceData, slot, this.market);
+        }
+        else {
+            console.error(`Unknown market type: ${this.order.marketType}`);
+        }
+    }
+    isVammNode() {
+        return false;
+    }
+}
+exports.OrderNode = OrderNode;
+class LimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.price;
+    }
+}
+exports.LimitOrderNode = LimitOrderNode;
+class FloatingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.oraclePriceOffset;
+    }
+}
+exports.FloatingLimitOrderNode = FloatingLimitOrderNode;
+class MarketOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.MarketOrderNode = MarketOrderNode;
+class TriggerOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.triggerPrice;
+    }
+}
+exports.TriggerOrderNode = TriggerOrderNode;
+function createNode(nodeType, order, market, userAccount) {
+    switch (nodeType) {
+        case 'floatingLimit':
+            return new FloatingLimitOrderNode(order, market, userAccount);
+        case 'limit':
+            return new LimitOrderNode(order, market, userAccount);
+        case 'market':
+            return new MarketOrderNode(order, market, userAccount);
+        case 'trigger':
+            return new TriggerOrderNode(order, market, userAccount);
+        default:
+            throw Error(`Unknown DLOBNode type ${nodeType}`);
+    }
+}
+exports.createNode = createNode;