@drift-labs/sdk 2.0.19 → 2.1.0

package/lib/dlob/DLOB.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="bn.js" />
 import { NodeList } from './NodeList';
-import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, MarketTypeStr, StateAccount, UserMap } from '..';
+import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, MarketTypeStr, StateAccount, UserMap, OrderRecord, OrderActionRecord } from '..';
 import { PublicKey } from '@solana/web3.js';
-import { DLOBNode, TriggerOrderNode } from '..';
+import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
 import { DLOBOrders } from './DLOBOrders';
 export declare type MarketNodeLists = {
     limit: {
@@ -43,10 +43,15 @@ export declare class DLOB {
      */
     initFromUserMap(userMap: UserMap): Promise<boolean>;
     initFromOrders(dlobOrders: DLOBOrders): boolean;
+    handleOrderRecord(record: OrderRecord): void;
+    handleOrderActionRecord(record: OrderActionRecord): void;
     insertOrder(order: Order, userAccount: PublicKey, onInsert?: OrderBookCallback): void;
     addOrderList(marketType: MarketTypeStr, marketIndex: number): void;
+    updateOrder(order: Order, userAccount: PublicKey, cumulativeBaseAssetAmountFilled: BN, onUpdate?: OrderBookCallback): void;
     trigger(order: Order, userAccount: PublicKey, onTrigger?: OrderBookCallback): void;
+    delete(order: Order, userAccount: PublicKey, onDelete?: OrderBookCallback): void;
     getListForOrder(order: Order): NodeList<any> | undefined;
+    getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
     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[];
@@ -71,6 +76,6 @@ export declare class DLOB {
     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;
+    getNodeLists(): Generator<NodeList<DLOBNodeType>>;
 }
 export {};

package/lib/dlob/DLOB.js

@@ -63,6 +63,56 @@ class DLOB {
         this.initialized = true;
         return true;
     }
+    handleOrderRecord(record) {
+        this.insertOrder(record.order, record.user);
+    }
+    handleOrderActionRecord(record) {
+        if ((0, __1.isOneOfVariant)(record.action, ['place', 'expire'])) {
+            return;
+        }
+        if ((0, __1.isVariant)(record.action, 'trigger')) {
+            if (record.taker !== null) {
+                const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+                if (takerOrder) {
+                    this.trigger(takerOrder, record.taker);
+                }
+            }
+            if (record.maker !== null) {
+                const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+                if (makerOrder) {
+                    this.trigger(makerOrder, record.maker);
+                }
+            }
+        }
+        else if ((0, __1.isVariant)(record.action, 'fill')) {
+            if (record.taker !== null) {
+                const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+                if (takerOrder) {
+                    this.updateOrder(takerOrder, record.taker, record.takerOrderCumulativeBaseAssetAmountFilled);
+                }
+            }
+            if (record.maker !== null) {
+                const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+                if (makerOrder) {
+                    this.updateOrder(makerOrder, record.maker, record.makerOrderCumulativeBaseAssetAmountFilled);
+                }
+            }
+        }
+        else if ((0, __1.isVariant)(record.action, 'cancel')) {
+            if (record.taker !== null) {
+                const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+                if (takerOrder) {
+                    this.delete(takerOrder, record.taker);
+                }
+            }
+            if (record.maker !== null) {
+                const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+                if (makerOrder) {
+                    this.delete(makerOrder, record.maker);
+                }
+            }
+        }
+    }
     insertOrder(order, userAccount, onInsert) {
         var _a;
         if ((0, __1.isVariant)(order.status, 'init')) {
@@ -102,11 +152,29 @@ class DLOB {
             },
         });
     }
+    updateOrder(order, userAccount, cumulativeBaseAssetAmountFilled, onUpdate) {
+        var _a;
+        if (order.baseAssetAmount.eq(cumulativeBaseAssetAmountFilled)) {
+            this.delete(order, userAccount);
+            return;
+        }
+        if (order.baseAssetAmountFilled.eq(cumulativeBaseAssetAmountFilled)) {
+            return;
+        }
+        order.baseAssetAmountFilled = cumulativeBaseAssetAmountFilled;
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.update(order, userAccount);
+        if (onUpdate) {
+            onUpdate();
+        }
+    }
     trigger(order, userAccount, onTrigger) {
         var _a;
         if ((0, __1.isVariant)(order.status, 'init')) {
             return;
         }
+        if ((0, __1.isTriggered)(order)) {
+            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'];
@@ -116,6 +184,16 @@ class DLOB {
             onTrigger();
         }
     }
+    delete(order, userAccount, onDelete) {
+        var _a;
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.remove(order, userAccount);
+        if (onDelete) {
+            onDelete();
+        }
+    }
     getListForOrder(order) {
         const isInactiveTriggerOrder = (0, __1.mustBeTriggered)(order) && !(0, __1.isTriggered)(order);
         let type;
@@ -144,6 +222,15 @@ class DLOB {
         }
         return this.orderLists.get(marketType).get(order.marketIndex)[type][subType];
     }
+    getOrder(orderId, userAccount) {
+        for (const nodeList of this.getNodeLists()) {
+            const node = nodeList.get(orderId, userAccount);
+            if (node) {
+                return node.order;
+            }
+        }
+        return undefined;
+    }
     findNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, ts, marketType, oraclePriceData, stateAccount, marketAccount) {
         if ((0, exchangeStatus_1.fillPaused)(stateAccount, marketAccount)) {
             return [];
@@ -288,6 +375,9 @@ class DLOB {
         const nodesToFill = new Array();
         const marketTypeStr = (0, __1.getVariant)(marketType);
         const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if (!nodeLists) {
+            return nodesToFill;
+        }
         // All bids/asks that can expire
         const bidGenerators = [
             nodeLists.limit.bid.getGenerator(),
@@ -641,66 +731,38 @@ class DLOB {
         }
     }
     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));
+        const dlobOrders = [];
+        for (const nodeList of this.getNodeLists()) {
+            for (const node of nodeList.getGenerator()) {
+                dlobOrders.push({
+                    user: node.userAccount,
+                    order: node.order,
+                });
+            }
         }
         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,
-            });
+    *getNodeLists() {
+        for (const [_, nodeLists] of this.orderLists.get('perp')) {
+            yield nodeLists.limit.bid;
+            yield nodeLists.limit.ask;
+            yield nodeLists.market.bid;
+            yield nodeLists.market.ask;
+            yield nodeLists.floatingLimit.bid;
+            yield nodeLists.floatingLimit.ask;
+            yield nodeLists.trigger.above;
+            yield nodeLists.trigger.below;
+        }
+        for (const [_, nodeLists] of this.orderLists.get('spot')) {
+            yield nodeLists.limit.bid;
+            yield nodeLists.limit.ask;
+            yield nodeLists.market.bid;
+            yield nodeLists.market.ask;
+            yield nodeLists.floatingLimit.bid;
+            yield nodeLists.floatingLimit.ask;
+            yield nodeLists.trigger.above;
+            yield nodeLists.trigger.below;
         }
-        return orders;
     }
 }
 exports.DLOB = DLOB;

package/lib/dlob/NodeList.d.ts

@@ -21,6 +21,7 @@ export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLO
     remove(order: Order, userAccount: PublicKey): void;
     getGenerator(): Generator<DLOBNode>;
     has(order: Order, userAccount: PublicKey): boolean;
+    get(orderId: number, userAccount: PublicKey): DLOBNodeMap[NodeType] | undefined;
     print(): void;
     printTop(): void;
 }

package/lib/dlob/NodeList.js

@@ -104,6 +104,9 @@ class NodeList {
     has(order, userAccount) {
         return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
     }
+    get(orderId, userAccount) {
+        return this.nodeMap.get(getOrderSignature(orderId, userAccount));
+    }
     print() {
         let currentNode = this.head;
         while (currentNode !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.0.19",
+	"version": "2.1.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/dlob/DLOB.ts

@@ -24,6 +24,8 @@ import {
 	isTriggered,
 	getLimitPrice,
 	UserMap,
+	OrderRecord,
+	OrderActionRecord,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
@@ -131,6 +133,68 @@ export class DLOB {
 		return true;
 	}
 
+	public handleOrderRecord(record: OrderRecord): void {
+		this.insertOrder(record.order, record.user);
+	}
+
+	public handleOrderActionRecord(record: OrderActionRecord): void {
+		if (isOneOfVariant(record.action, ['place', 'expire'])) {
+			return;
+		}
+
+		if (isVariant(record.action, 'trigger')) {
+			if (record.taker !== null) {
+				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+				if (takerOrder) {
+					this.trigger(takerOrder, record.taker);
+				}
+			}
+
+			if (record.maker !== null) {
+				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+				if (makerOrder) {
+					this.trigger(makerOrder, record.maker);
+				}
+			}
+		} else if (isVariant(record.action, 'fill')) {
+			if (record.taker !== null) {
+				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+				if (takerOrder) {
+					this.updateOrder(
+						takerOrder,
+						record.taker,
+						record.takerOrderCumulativeBaseAssetAmountFilled
+					);
+				}
+			}
+
+			if (record.maker !== null) {
+				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+				if (makerOrder) {
+					this.updateOrder(
+						makerOrder,
+						record.maker,
+						record.makerOrderCumulativeBaseAssetAmountFilled
+					);
+				}
+			}
+		} else if (isVariant(record.action, 'cancel')) {
+			if (record.taker !== null) {
+				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+				if (takerOrder) {
+					this.delete(takerOrder, record.taker);
+				}
+			}
+
+			if (record.maker !== null) {
+				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+				if (makerOrder) {
+					this.delete(makerOrder, record.maker);
+				}
+			}
+		}
+	}
+
 	public insertOrder(
 		order: Order,
 		userAccount: PublicKey,
@@ -179,6 +243,29 @@ export class DLOB {
 		});
 	}
 
+	public updateOrder(
+		order: Order,
+		userAccount: PublicKey,
+		cumulativeBaseAssetAmountFilled: BN,
+		onUpdate?: OrderBookCallback
+	): void {
+		if (order.baseAssetAmount.eq(cumulativeBaseAssetAmountFilled)) {
+			this.delete(order, userAccount);
+			return;
+		}
+
+		if (order.baseAssetAmountFilled.eq(cumulativeBaseAssetAmountFilled)) {
+			return;
+		}
+
+		order.baseAssetAmountFilled = cumulativeBaseAssetAmountFilled;
+		this.getListForOrder(order)?.update(order, userAccount);
+
+		if (onUpdate) {
+			onUpdate();
+		}
+	}
+
 	public trigger(
 		order: Order,
 		userAccount: PublicKey,
@@ -188,6 +275,10 @@ export class DLOB {
 			return;
 		}
 
+		if (isTriggered(order)) {
+			return;
+		}
+
 		const marketType = getVariant(order.marketType) as MarketTypeStr;
 
 		const triggerList = this.orderLists.get(marketType).get(order.marketIndex)
@@ -200,6 +291,21 @@ export class DLOB {
 		}
 	}
 
+	public delete(
+		order: Order,
+		userAccount: PublicKey,
+		onDelete?: OrderBookCallback
+	): void {
+		if (isVariant(order.status, 'init')) {
+			return;
+		}
+
+		this.getListForOrder(order)?.remove(order, userAccount);
+		if (onDelete) {
+			onDelete();
+		}
+	}
+
 	public getListForOrder(order: Order): NodeList<any> | undefined {
 		const isInactiveTriggerOrder =
 			mustBeTriggered(order) && !isTriggered(order);
@@ -233,6 +339,17 @@ export class DLOB {
 		];
 	}
 
+	public getOrder(orderId: number, userAccount: PublicKey): Order | undefined {
+		for (const nodeList of this.getNodeLists()) {
+			const node = nodeList.get(orderId, userAccount);
+			if (node) {
+				return node.order;
+			}
+		}
+
+		return undefined;
+	}
+
 	public findNodesToFill(
 		marketIndex: number,
 		fallbackBid: BN | undefined,
@@ -577,6 +694,10 @@ export class DLOB {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
 
+		if (!nodeLists) {
+			return nodesToFill;
+		}
+
 		// All bids/asks that can expire
 		const bidGenerators = [
 			nodeLists.limit.bid.getGenerator(),
@@ -1160,86 +1281,41 @@ export class DLOB {
 	}
 
 	public getDLOBOrders(): DLOBOrders {
-		let dlobOrders: DLOBOrders = [];
+		const dlobOrders: DLOBOrders = [];
 
-		for (const [marketIndex, nodeLists] of this.orderLists.get('perp')) {
-			dlobOrders = dlobOrders.concat(
-				this.getOrdersForMarket(marketIndex, MarketType.PERP, nodeLists)
-			);
-		}
-
-		for (const [marketIndex, nodeLists] of this.orderLists.get('spot')) {
-			dlobOrders = dlobOrders.concat(
-				this.getOrdersForMarket(marketIndex, MarketType.SPOT, nodeLists)
-			);
+		for (const nodeList of this.getNodeLists()) {
+			for (const node of nodeList.getGenerator()) {
+				dlobOrders.push({
+					user: node.userAccount,
+					order: node.order,
+				});
+			}
 		}
 
 		return dlobOrders;
 	}
 
-	getOrdersForMarket(
-		marketIndex: number,
-		marketType: MarketType,
-		nodeLists: MarketNodeLists
-	): DLOBOrders {
-		const orders: { user: PublicKey; order: Order }[] = [];
-
-		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,
-			});
+	*getNodeLists(): Generator<NodeList<DLOBNodeType>> {
+		for (const [_, nodeLists] of this.orderLists.get('perp')) {
+			yield nodeLists.limit.bid;
+			yield nodeLists.limit.ask;
+			yield nodeLists.market.bid;
+			yield nodeLists.market.ask;
+			yield nodeLists.floatingLimit.bid;
+			yield nodeLists.floatingLimit.ask;
+			yield nodeLists.trigger.above;
+			yield nodeLists.trigger.below;
 		}
 
-		for (const node of nodeLists.market.ask.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
+		for (const [_, nodeLists] of this.orderLists.get('spot')) {
+			yield nodeLists.limit.bid;
+			yield nodeLists.limit.ask;
+			yield nodeLists.market.bid;
+			yield nodeLists.market.ask;
+			yield nodeLists.floatingLimit.bid;
+			yield nodeLists.floatingLimit.ask;
+			yield nodeLists.trigger.above;
+			yield nodeLists.trigger.below;
 		}
-
-		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;
 	}
 }

package/src/dlob/NodeList.ts

@@ -146,6 +146,13 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 		return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
 	}
 
+	public get(
+		orderId: number,
+		userAccount: PublicKey
+	): DLOBNodeMap[NodeType] | undefined {
+		return this.nodeMap.get(getOrderSignature(orderId, userAccount));
+	}
+
 	public print(): void {
 		let currentNode = this.head;
 		while (currentNode !== undefined) {