@drift-labs/sdk 2.0.16 → 2.0.18

package/lib/dlob/DLOB.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="bn.js" />
 import { NodeList } from './NodeList';
-import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, UserMapInterface, MarketTypeStr, StateAccount } from '..';
+import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, MarketTypeStr, StateAccount, UserMap } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, TriggerOrderNode } from '..';
+import { DLOBOrders } from './DLOBOrders';
 export declare type MarketNodeLists = {
     limit: {
         ask: NodeList<'limit'>;
@@ -32,30 +33,21 @@ export declare type NodeToTrigger = {
 export declare class DLOB {
     openOrders: Map<MarketTypeStr, Set<string>>;
     orderLists: Map<MarketTypeStr, Map<number, MarketNodeLists>>;
-    stateAccount: StateAccount;
-    marketIndexToAccount: Map<MarketTypeStr, Map<number, PerpMarketAccount | SpotMarketAccount>>;
-    userMap: UserMapInterface;
-    silent: boolean;
     initialized: boolean;
-    /**
-     *
-     * @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: PerpMarketAccount[], spotMarkets: SpotMarketAccount[], stateAccount: StateAccount, userMap: UserMapInterface, silent?: boolean);
+    constructor();
     clear(): void;
     /**
      * initializes a new DLOB instance
      *
      * @returns a promise that resolves when the DLOB is initialized
      */
-    init(): Promise<boolean>;
+    initFromUserMap(userMap: UserMap): Promise<boolean>;
+    initFromOrders(dlobOrders: DLOBOrders): boolean;
     insertOrder(order: Order, userAccount: PublicKey, onInsert?: OrderBookCallback): void;
+    addOrderList(marketType: MarketTypeStr, marketIndex: number): void;
     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[];
+    findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): 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(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
@@ -76,7 +68,9 @@ export declare class DLOB {
     };
     getBestAsk(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
     getBestBid(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
-    findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType): NodeToTrigger[];
+    findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType, stateAccount: StateAccount): NodeToTrigger[];
     printTopOfOrderLists(sdkConfig: any, driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
+    getDLOBOrders(): DLOBOrders;
+    getOrdersForMarket(marketIndex: number, marketType: MarketType, nodeLists: MarketNodeLists): DLOBOrders;
 }
 export {};

package/lib/dlob/DLOB.js

@@ -5,72 +5,14 @@ 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) {
+    constructor() {
         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()) {
@@ -90,22 +32,18 @@ class DLOB {
             }
         }
         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() {
+    async initFromUserMap(userMap) {
         if (this.initialized) {
             return false;
         }
-        // initialize the dlob with the user map (prevents hitting getProgramAccounts)
-        for (const user of this.userMap.values()) {
+        // initialize the dlob with the user map
+        for (const user of userMap.values()) {
             const userAccount = user.getUserAccount();
             const userAccountPubkey = user.getUserAccountPublicKey();
             for (const order of userAccount.orders) {
@@ -115,22 +53,55 @@ class DLOB {
         this.initialized = true;
         return true;
     }
+    initFromOrders(dlobOrders) {
+        if (this.initialized) {
+            return false;
+        }
+        for (const { user, order } of dlobOrders) {
+            this.insertOrder(order, user);
+        }
+        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 (!this.orderLists.get(marketType).has(order.marketIndex)) {
+            this.addOrderList(marketType, order.marketIndex);
+        }
         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);
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount);
         if (onInsert) {
             onInsert();
         }
     }
+    addOrderList(marketType, marketIndex) {
+        this.orderLists.get(marketType).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'),
+            },
+        });
+    }
     trigger(order, userAccount, onTrigger) {
         var _a;
         if ((0, __1.isVariant)(order.status, 'init')) {
@@ -140,7 +111,7 @@ class DLOB {
         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);
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.insert(order, marketType, userAccount);
         if (onTrigger) {
             onTrigger();
         }
@@ -173,14 +144,11 @@ class DLOB {
         }
         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)) {
+    findNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, ts, marketType, oraclePriceData, stateAccount, marketAccount) {
+        if ((0, exchangeStatus_1.fillPaused)(stateAccount, marketAccount)) {
             return [];
         }
-        const isAmmPaused = (0, exchangeStatus_1.ammPaused)(this.stateAccount, marketAccount);
+        const isAmmPaused = (0, exchangeStatus_1.ammPaused)(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
@@ -254,11 +222,9 @@ class DLOB {
         for (const takerNode of takerNodeGenerator) {
             const makerNodeGenerator = makerNodeGeneratorFn(marketIndex, slot, marketType, oraclePriceData);
             for (const makerNode of makerNodeGenerator) {
-                const bidUserAuthority = this.userMap.getUserAuthority(makerNode.userAccount.toString());
-                const askUserAuthority = this.userMap.getUserAuthority(takerNode.userAccount.toString());
-                // Can't match orders from the same authority
-                const sameAuthority = bidUserAuthority.equals(askUserAuthority);
-                if (sameAuthority) {
+                // Can't match orders from the same user
+                const sameUser = takerNode.userAccount.equals(makerNode.userAccount);
+                if (sameUser) {
                     continue;
                 }
                 const makerPrice = makerNode.getPrice(oraclePriceData, slot);
@@ -374,10 +340,11 @@ class DLOB {
     }
     *getMarketBids(marketIndex, marketType) {
         const marketTypeStr = (0, __1.getVariant)(marketType);
-        const generator = this.orderLists
-            .get(marketTypeStr)
-            .get(marketIndex)
-            .market.bid.getGenerator();
+        const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if (!orderLists) {
+            return;
+        }
+        const generator = orderLists.market.bid.getGenerator();
         for (const marketBidNode of generator) {
             if (marketBidNode.isBaseFilled()) {
                 continue;
@@ -387,10 +354,11 @@ class DLOB {
     }
     *getMarketAsks(marketIndex, marketType) {
         const marketTypeStr = (0, __1.getVariant)(marketType);
-        const generator = this.orderLists
-            .get(marketTypeStr)
-            .get(marketIndex)
-            .market.ask.getGenerator();
+        const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if (!orderLists) {
+            return;
+        }
+        const generator = orderLists.market.ask.getGenerator();
         for (const marketAskNode of generator) {
             if (marketAskNode.isBaseFilled()) {
                 continue;
@@ -435,14 +403,6 @@ class DLOB {
                     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();
             }
@@ -457,6 +417,9 @@ class DLOB {
         }
         const marketTypeStr = (0, __1.getVariant)(marketType);
         const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if (!nodeLists) {
+            return;
+        }
         const generatorList = [
             nodeLists.limit.ask.getGenerator(),
             nodeLists.floatingLimit.ask.getGenerator(),
@@ -471,6 +434,9 @@ class DLOB {
         }
         const marketTypeStr = (0, __1.getVariant)(marketType);
         const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if (!nodeLists) {
+            return;
+        }
         const generatorList = [
             nodeLists.limit.bid.getGenerator(),
             nodeLists.floatingLimit.bid.getGenerator(),
@@ -523,11 +489,9 @@ class DLOB {
                 }
                 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)) {
+                // Can't match orders from the same user
+                const sameUser = bidNode.userAccount.equals(askNode.userAccount);
+                if (sameUser || (bidOrder.postOnly && askOrder.postOnly)) {
                     continue;
                 }
                 const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
@@ -590,8 +554,8 @@ class DLOB {
             .next()
             .value.getPrice(oraclePriceData, slot);
     }
-    findNodesToTrigger(marketIndex, slot, oraclePrice, marketType) {
-        if ((0, exchangeStatus_1.exchangePaused)(this.stateAccount)) {
+    findNodesToTrigger(marketIndex, slot, oraclePrice, marketType, stateAccount) {
+        if ((0, exchangeStatus_1.exchangePaused)(stateAccount)) {
             return [];
         }
         const nodesToTrigger = [];
@@ -671,5 +635,67 @@ class DLOB {
             console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION).toFixed(3), `(${bidSpread.toFixed(4)}%)`);
         }
     }
+    getDLOBOrders() {
+        let dlobOrders = [];
+        for (const [marketIndex, nodeLists] of this.orderLists.get('perp')) {
+            dlobOrders = dlobOrders.concat(this.getOrdersForMarket(marketIndex, __1.MarketType.PERP, nodeLists));
+        }
+        for (const [marketIndex, nodeLists] of this.orderLists.get('spot')) {
+            dlobOrders = dlobOrders.concat(this.getOrdersForMarket(marketIndex, __1.MarketType.SPOT, nodeLists));
+        }
+        return dlobOrders;
+    }
+    getOrdersForMarket(marketIndex, marketType, nodeLists) {
+        const orders = [];
+        for (const node of nodeLists.limit.bid.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.limit.ask.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.market.bid.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.market.ask.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.floatingLimit.bid.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.floatingLimit.ask.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.trigger.below.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        for (const node of nodeLists.trigger.above.getGenerator()) {
+            orders.push({
+                user: node.userAccount,
+                order: node.order,
+            });
+        }
+        return orders;
+    }
 }
 exports.DLOB = DLOB;

package/lib/dlob/DLOBNode.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="bn.js" />
-import { BN, SpotMarketAccount, PerpMarketAccount, OraclePriceData, Order } from '..';
+import { BN, OraclePriceData, Order } from '..';
 import { PublicKey } from '@solana/web3.js';
 export interface DLOBNode {
     getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
@@ -8,16 +8,14 @@ export interface DLOBNode {
     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);
+    constructor(order: Order, userAccount: PublicKey);
     abstract getSortValue(order: Order): BN;
     getLabel(): string;
     getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
@@ -51,4 +49,4 @@ export declare type DLOBNodeMap = {
     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];
+export declare function createNode<T extends DLOBNodeType>(nodeType: T, order: Order, userAccount: PublicKey): DLOBNodeMap[T];

package/lib/dlob/DLOBNode.js

@@ -4,11 +4,10 @@ exports.createNode = exports.TriggerOrderNode = exports.MarketOrderNode = export
 const __1 = require("..");
 const NodeList_1 = require("./NodeList");
 class OrderNode {
-    constructor(order, market, userAccount) {
+    constructor(order, userAccount) {
         this.haveFilled = false;
         this.haveTrigger = false;
         this.order = order;
-        this.market = market;
         this.userAccount = userAccount;
         this.sortValue = this.getSortValue(order);
     }
@@ -60,16 +59,16 @@ class TriggerOrderNode extends OrderNode {
     }
 }
 exports.TriggerOrderNode = TriggerOrderNode;
-function createNode(nodeType, order, market, userAccount) {
+function createNode(nodeType, order, userAccount) {
     switch (nodeType) {
         case 'floatingLimit':
-            return new FloatingLimitOrderNode(order, market, userAccount);
+            return new FloatingLimitOrderNode(order, userAccount);
         case 'limit':
-            return new LimitOrderNode(order, market, userAccount);
+            return new LimitOrderNode(order, userAccount);
         case 'market':
-            return new MarketOrderNode(order, market, userAccount);
+            return new MarketOrderNode(order, userAccount);
         case 'trigger':
-            return new TriggerOrderNode(order, market, userAccount);
+            return new TriggerOrderNode(order, userAccount);
         default:
             throw Error(`Unknown DLOBNode type ${nodeType}`);
     }

package/lib/dlob/DLOBOrders.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { PublicKey } from '@solana/web3.js';
+import { Idl } from '@project-serum/anchor';
+import { Order } from '../types';
+export declare type DLOBOrder = {
+    user: PublicKey;
+    order: Order;
+};
+export declare type DLOBOrders = DLOBOrder[];
+export declare class DLOBOrdersCoder {
+    private idl;
+    constructor(idl: Idl);
+    static create(): DLOBOrdersCoder;
+    encode(dlobOrders: DLOBOrders): Buffer;
+    decode(buffer: Buffer): DLOBOrders;
+}

package/lib/dlob/DLOBOrders.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOBOrdersCoder = void 0;
+const idl_1 = require("@project-serum/anchor/dist/cjs/coder/borsh/idl");
+const dlobIdl_json_1 = __importDefault(require("./dlobIdl.json"));
+class DLOBOrdersCoder {
+    constructor(idl) {
+        this.idl = idl;
+    }
+    static create() {
+        return new DLOBOrdersCoder(dlobIdl_json_1.default);
+    }
+    encode(dlobOrders) {
+        const layout = idl_1.IdlCoder.fieldLayout({
+            type: {
+                vec: {
+                    defined: 'DLOBOrder',
+                },
+            },
+        }, this.idl.types);
+        const size = 150 * dlobOrders.length;
+        const buffer = Buffer.alloc(size);
+        const len = layout.encode(dlobOrders, buffer);
+        return buffer.slice(0, len);
+    }
+    decode(buffer) {
+        const layout = idl_1.IdlCoder.fieldLayout({
+            type: {
+                vec: {
+                    defined: 'DLOBOrder',
+                },
+            },
+        }, this.idl.types);
+        return layout.decode(buffer);
+    }
+}
+exports.DLOBOrdersCoder = DLOBOrdersCoder;

package/lib/dlob/NodeList.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="bn.js" />
-import { BN, MarketTypeStr, Order, PerpMarketAccount, SpotMarketAccount } from '..';
+import { BN, MarketTypeStr, Order } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeMap } from './DLOBNode';
 export declare type SortDirection = 'asc' | 'desc';
@@ -15,7 +15,7 @@ export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLO
     nodeMap: Map<string, DLOBNodeMap[NodeType]>;
     constructor(nodeType: NodeType, sortDirection: SortDirection);
     clear(): void;
-    insert(order: Order, marketType: MarketTypeStr, market: PerpMarketAccount | SpotMarketAccount, userAccount: PublicKey): void;
+    insert(order: Order, marketType: MarketTypeStr, userAccount: PublicKey): void;
     prependNode(currentNode: DLOBNodeMap[NodeType], newNode: DLOBNodeMap[NodeType]): boolean;
     update(order: Order, userAccount: PublicKey): void;
     remove(order: Order, userAccount: PublicKey): void;

package/lib/dlob/NodeList.js

@@ -19,17 +19,11 @@ class NodeList {
         this.length = 0;
         this.nodeMap.clear();
     }
-    insert(order, marketType, market, userAccount) {
+    insert(order, marketType, userAccount) {
         if ((0, __1.isVariant)(order.status, 'init')) {
             return;
         }
-        if (marketType === 'spot') {
-            market = market;
-        }
-        else if (marketType === 'perp') {
-            market = market;
-        }
-        const newNode = (0, DLOBNode_1.createNode)(this.nodeType, order, market, userAccount);
+        const newNode = (0, DLOBNode_1.createNode)(this.nodeType, order, userAccount);
         const orderSignature = getOrderSignature(order.orderId, userAccount);
         if (this.nodeMap.has(orderSignature)) {
             return;
@@ -135,7 +129,6 @@ function* getVammNodeGenerator(price) {
         getPrice: () => price,
         isVammNode: () => true,
         order: undefined,
-        market: undefined,
         userAccount: undefined,
         isBaseFilled: () => false,
         haveFilled: false,