@drift-labs/sdk 2.0.16 → 2.0.18

package/src/dlob/DLOB.ts

@@ -17,17 +17,18 @@ import {
 	PerpMarketAccount,
 	OraclePriceData,
 	SlotSubscriber,
-	UserMapInterface,
 	MarketTypeStr,
 	StateAccount,
 	isMarketOrder,
 	mustBeTriggered,
 	isTriggered,
 	getLimitPrice,
+	UserMap,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
 import { ammPaused, exchangePaused, fillPaused } from '../math/exchangeStatus';
+import { DLOBOrders } from './DLOBOrders';
 
 export type MarketNodeLists = {
 	limit: {
@@ -62,87 +63,14 @@ export type NodeToTrigger = {
 export class DLOB {
 	openOrders = new Map<MarketTypeStr, Set<string>>();
 	orderLists = new Map<MarketTypeStr, Map<number, MarketNodeLists>>();
-	stateAccount: StateAccount;
-	marketIndexToAccount = new Map<
-		MarketTypeStr,
-		Map<number, PerpMarketAccount | SpotMarketAccount>
-	>();
-
-	userMap: UserMapInterface;
-	silent = false;
-	initialized = false;
 
-	/**
-	 *
-	 * @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
-	 */
-	public constructor(
-		perpMarkets: PerpMarketAccount[],
-		spotMarkets: SpotMarketAccount[],
-		stateAccount: StateAccount,
-		userMap: UserMapInterface,
-		silent?: boolean
-	) {
-		this.stateAccount = stateAccount;
-		this.userMap = userMap;
-		this.silent = silent;
+	initialized = false;
 
+	public constructor() {
 		this.openOrders.set('perp', new Set<string>());
 		this.openOrders.set('spot', new Set<string>());
 		this.orderLists.set('perp', new Map<number, MarketNodeLists>());
 		this.orderLists.set('spot', new Map<number, MarketNodeLists>());
-		this.marketIndexToAccount.set('perp', new Map<number, PerpMarketAccount>());
-		this.marketIndexToAccount.set('spot', new Map<number, SpotMarketAccount>());
-
-		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('limit', 'asc'),
-					bid: new NodeList('limit', 'desc'),
-				},
-				floatingLimit: {
-					ask: new NodeList('floatingLimit', 'asc'),
-					bid: new NodeList('floatingLimit', 'desc'),
-				},
-				market: {
-					ask: new NodeList('market', 'asc'),
-					bid: new NodeList('market', 'asc'), // always sort ascending for market orders
-				},
-				trigger: {
-					above: new NodeList('trigger', 'asc'),
-					below: new 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('limit', 'asc'),
-					bid: new NodeList('limit', 'desc'),
-				},
-				floatingLimit: {
-					ask: new NodeList('floatingLimit', 'asc'),
-					bid: new NodeList('floatingLimit', 'desc'),
-				},
-				market: {
-					ask: new NodeList('market', 'asc'),
-					bid: new NodeList('market', 'asc'), // always sort ascending for market orders
-				},
-				trigger: {
-					above: new NodeList('trigger', 'asc'),
-					below: new NodeList('trigger', 'desc'),
-				},
-			});
-		}
 	}
 
 	public clear() {
@@ -164,11 +92,6 @@ export class DLOB {
 			}
 		}
 		this.orderLists.clear();
-
-		for (const marketType of this.marketIndexToAccount.keys()) {
-			this.marketIndexToAccount.get(marketType).clear();
-		}
-		this.marketIndexToAccount.clear();
 	}
 
 	/**
@@ -176,13 +99,13 @@ export class DLOB {
 	 *
 	 * @returns a promise that resolves when the DLOB is initialized
 	 */
-	public async init(): Promise<boolean> {
+	public async initFromUserMap(userMap: UserMap): Promise<boolean> {
 		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();
 
@@ -195,6 +118,19 @@ export class DLOB {
 		return true;
 	}
 
+	public initFromOrders(dlobOrders: DLOBOrders): boolean {
+		if (this.initialized) {
+			return false;
+		}
+
+		for (const { user, order } of dlobOrders) {
+			this.insertOrder(order, user);
+		}
+
+		this.initialized = true;
+		return true;
+	}
+
 	public insertOrder(
 		order: Order,
 		userAccount: PublicKey,
@@ -206,23 +142,43 @@ export class DLOB {
 
 		const marketType = getVariant(order.marketType) as MarketTypeStr;
 
+		if (!this.orderLists.get(marketType).has(order.marketIndex)) {
+			this.addOrderList(marketType, order.marketIndex);
+		}
+
 		if (isVariant(order.status, 'open')) {
 			this.openOrders
 				.get(marketType)
 				.add(getOrderSignature(order.orderId, userAccount));
 		}
-		this.getListForOrder(order)?.insert(
-			order,
-			marketType,
-			this.marketIndexToAccount.get(marketType).get(order.marketIndex),
-			userAccount
-		);
+		this.getListForOrder(order)?.insert(order, marketType, userAccount);
 
 		if (onInsert) {
 			onInsert();
 		}
 	}
 
+	addOrderList(marketType: MarketTypeStr, marketIndex: number): void {
+		this.orderLists.get(marketType).set(marketIndex, {
+			limit: {
+				ask: new NodeList('limit', 'asc'),
+				bid: new NodeList('limit', 'desc'),
+			},
+			floatingLimit: {
+				ask: new NodeList('floatingLimit', 'asc'),
+				bid: new NodeList('floatingLimit', 'desc'),
+			},
+			market: {
+				ask: new NodeList('market', 'asc'),
+				bid: new NodeList('market', 'asc'), // always sort ascending for market orders
+			},
+			trigger: {
+				above: new NodeList('trigger', 'asc'),
+				below: new NodeList('trigger', 'desc'),
+			},
+		});
+	}
+
 	public trigger(
 		order: Order,
 		userAccount: PublicKey,
@@ -238,12 +194,7 @@ export class DLOB {
 			.trigger[isVariant(order.triggerCondition, 'above') ? 'above' : 'below'];
 		triggerList.remove(order, userAccount);
 
-		this.getListForOrder(order)?.insert(
-			order,
-			marketType,
-			this.marketIndexToAccount.get(marketType).get(order.marketIndex),
-			userAccount
-		);
+		this.getListForOrder(order)?.insert(order, marketType, userAccount);
 		if (onTrigger) {
 			onTrigger();
 		}
@@ -289,17 +240,15 @@ export class DLOB {
 		slot: number,
 		ts: number,
 		marketType: MarketType,
-		oraclePriceData: OraclePriceData
+		oraclePriceData: OraclePriceData,
+		stateAccount: StateAccount,
+		marketAccount: PerpMarketAccount | SpotMarketAccount
 	): NodeToFill[] {
-		const marketAccount = this.marketIndexToAccount
-			.get(getVariant(marketType) as MarketTypeStr)
-			.get(marketIndex);
-
-		if (fillPaused(this.stateAccount, marketAccount)) {
+		if (fillPaused(stateAccount, marketAccount)) {
 			return [];
 		}
 
-		const isAmmPaused = ammPaused(this.stateAccount, marketAccount);
+		const isAmmPaused = ammPaused(stateAccount, marketAccount);
 
 		const marketOrderNodesToFill: Array<NodeToFill> =
 			this.findMarketNodesToFill(
@@ -517,17 +466,9 @@ export class DLOB {
 			);
 
 			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;
 				}
 
@@ -701,10 +642,12 @@ export class DLOB {
 		marketType: MarketType
 	): Generator<DLOBNode> {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		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;
@@ -718,10 +661,12 @@ export class DLOB {
 		marketType: MarketType
 	): Generator<DLOBNode> {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		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;
@@ -782,17 +727,6 @@ export class DLOB {
 					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?.isBeingLiquidated()) {
-						bestGenerator.next = bestGenerator.generator.next();
-						continue;
-					}
-				}
-
 				yield bestGenerator.next.value;
 				bestGenerator.next = bestGenerator.generator.next();
 			} else {
@@ -813,6 +747,10 @@ export class DLOB {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
 
+		if (!nodeLists) {
+			return;
+		}
+
 		const generatorList = [
 			nodeLists.limit.ask.getGenerator(),
 			nodeLists.floatingLimit.ask.getGenerator(),
@@ -841,6 +779,10 @@ export class DLOB {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
 
+		if (!nodeLists) {
+			return;
+		}
+
 		const generatorList = [
 			nodeLists.limit.bid.getGenerator(),
 			nodeLists.floatingLimit.bid.getGenerator(),
@@ -949,16 +891,9 @@ export 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;
 				}
 
@@ -1074,9 +1009,10 @@ export class DLOB {
 		marketIndex: number,
 		slot: number,
 		oraclePrice: BN,
-		marketType: MarketType
+		marketType: MarketType,
+		stateAccount: StateAccount
 	): NodeToTrigger[] {
-		if (exchangePaused(this.stateAccount)) {
+		if (exchangePaused(stateAccount)) {
 			return [];
 		}
 
@@ -1216,4 +1152,88 @@ export class DLOB {
 			);
 		}
 	}
+
+	public getDLOBOrders(): DLOBOrders {
+		let 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)
+			);
+		}
+
+		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,
+			});
+		}
+
+		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;
+	}
 }

package/src/dlob/DLOBNode.ts

@@ -4,8 +4,6 @@ import {
 	convertToNumber,
 	getLimitPrice,
 	isVariant,
-	SpotMarketAccount,
-	PerpMarketAccount,
 	PRICE_PRECISION,
 	OraclePriceData,
 	Order,
@@ -21,24 +19,17 @@ export interface DLOBNode {
 	isBaseFilled(): boolean;
 	haveFilled: boolean;
 	userAccount: PublicKey | undefined;
-	market: SpotMarketAccount | PerpMarketAccount;
 }
 
 export abstract class OrderNode implements DLOBNode {
 	order: Order;
-	market: SpotMarketAccount | PerpMarketAccount;
 	userAccount: PublicKey;
 	sortValue: BN;
 	haveFilled = false;
 	haveTrigger = false;
 
-	constructor(
-		order: Order,
-		market: SpotMarketAccount | PerpMarketAccount,
-		userAccount: PublicKey
-	) {
+	constructor(order: Order, userAccount: PublicKey) {
 		this.order = order;
-		this.market = market;
 		this.userAccount = userAccount;
 		this.sortValue = this.getSortValue(order);
 	}
@@ -137,18 +128,17 @@ export type DLOBNodeType =
 export function createNode<T extends DLOBNodeType>(
 	nodeType: T,
 	order: Order,
-	market: SpotMarketAccount | PerpMarketAccount,
 	userAccount: PublicKey
 ): DLOBNodeMap[T] {
 	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/src/dlob/DLOBOrders.ts

@@ -0,0 +1,49 @@
+import { PublicKey } from '@solana/web3.js';
+import { Idl } from '@project-serum/anchor';
+import { IdlCoder } from '@project-serum/anchor/dist/cjs/coder/borsh/idl';
+import dlobIDL from './dlobIdl.json';
+import { Order } from '../types';
+
+export type DLOBOrder = { user: PublicKey; order: Order };
+
+export type DLOBOrders = DLOBOrder[];
+
+export class DLOBOrdersCoder {
+	public constructor(private idl: Idl) {}
+
+	static create(): DLOBOrdersCoder {
+		return new DLOBOrdersCoder(dlobIDL as Idl);
+	}
+
+	public encode(dlobOrders: DLOBOrders): Buffer {
+		const layout = 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);
+	}
+
+	public decode(buffer: Buffer): DLOBOrders {
+		const layout = IdlCoder.fieldLayout(
+			{
+				type: {
+					vec: {
+						defined: 'DLOBOrder',
+					},
+				},
+			},
+			this.idl.types
+		);
+		return layout.decode(buffer) as DLOBOrders;
+	}
+}

package/src/dlob/NodeList.ts

@@ -1,11 +1,4 @@
-import {
-	BN,
-	isVariant,
-	MarketTypeStr,
-	Order,
-	PerpMarketAccount,
-	SpotMarketAccount,
-} from '..';
+import { BN, isVariant, MarketTypeStr, Order } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { createNode, DLOBNode, DLOBNodeMap } from './DLOBNode';
 
@@ -43,20 +36,13 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 	public insert(
 		order: Order,
 		marketType: MarketTypeStr,
-		market: PerpMarketAccount | SpotMarketAccount,
 		userAccount: PublicKey
 	): void {
 		if (isVariant(order.status, 'init')) {
 			return;
 		}
 
-		if (marketType === 'spot') {
-			market = market as SpotMarketAccount;
-		} else if (marketType === 'perp') {
-			market = market as PerpMarketAccount;
-		}
-
-		const newNode = createNode(this.nodeType, order, market, userAccount);
+		const newNode = createNode(this.nodeType, order, userAccount);
 
 		const orderSignature = getOrderSignature(order.orderId, userAccount);
 		if (this.nodeMap.has(orderSignature)) {
@@ -187,7 +173,6 @@ export function* getVammNodeGenerator(
 		getPrice: () => price,
 		isVammNode: () => true,
 		order: undefined,
-		market: undefined,
 		userAccount: undefined,
 		isBaseFilled: () => false,
 		haveFilled: false,