@drift-labs/sdk-browser 2.104.0-beta.21

package/src/dlob/DLOBNode.ts

@@ -0,0 +1,197 @@
+import {
+	AMM_RESERVE_PRECISION,
+	BN,
+	convertToNumber,
+	getLimitPrice,
+	isVariant,
+	PRICE_PRECISION,
+	OraclePriceData,
+	Order,
+	ZERO,
+} from '..';
+// import { PublicKey } from '@solana/web3.js';
+import { getOrderSignature } from './NodeList';
+
+export interface DLOBNode {
+	getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+	isVammNode(): boolean;
+	order: Order | undefined;
+	isBaseFilled(): boolean;
+	haveFilled: boolean;
+	userAccount: string | undefined;
+	isUserProtectedMaker: boolean;
+	isSwift: boolean | undefined;
+}
+
+export abstract class OrderNode implements DLOBNode {
+	order: Order;
+	userAccount: string;
+	sortValue: BN;
+	haveFilled = false;
+	haveTrigger = false;
+	isUserProtectedMaker: boolean;
+	isSwift: boolean;
+
+	constructor(
+		order: Order,
+		userAccount: string,
+		isUserProtectedMaker: boolean,
+		isSwift = false
+	) {
+		// Copy the order over to the node
+		this.order = { ...order };
+		this.userAccount = userAccount;
+		this.sortValue = this.getSortValue(order);
+		this.isUserProtectedMaker = isUserProtectedMaker;
+		this.isSwift = isSwift;
+	}
+
+	abstract getSortValue(order: Order): BN;
+
+	public getLabel(): string {
+		let msg = `Order ${getOrderSignature(
+			this.order.orderId,
+			this.userAccount
+		)}`;
+		msg += ` ${isVariant(this.order.direction, 'long') ? 'LONG' : 'SHORT'} `;
+		msg += `${convertToNumber(
+			this.order.baseAssetAmount,
+			AMM_RESERVE_PRECISION
+		).toFixed(3)}`;
+		if (this.order.price.gt(ZERO)) {
+			msg += ` @ ${convertToNumber(this.order.price, PRICE_PRECISION).toFixed(
+				3
+			)}`;
+		}
+		if (this.order.triggerPrice.gt(ZERO)) {
+			msg += ` ${
+				isVariant(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'
+			}`;
+			msg += ` ${convertToNumber(
+				this.order.triggerPrice,
+				PRICE_PRECISION
+			).toFixed(3)}`;
+		}
+		return msg;
+	}
+
+	getPrice(oraclePriceData: OraclePriceData, slot: number): BN {
+		return getLimitPrice(this.order, oraclePriceData, slot);
+	}
+
+	isBaseFilled(): boolean {
+		return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
+	}
+
+	isVammNode(): boolean {
+		return false;
+	}
+}
+
+export class TakingLimitOrderNode extends OrderNode {
+	next?: TakingLimitOrderNode;
+	previous?: TakingLimitOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.slot;
+	}
+}
+
+export class RestingLimitOrderNode extends OrderNode {
+	next?: RestingLimitOrderNode;
+	previous?: RestingLimitOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.price;
+	}
+}
+
+export class FloatingLimitOrderNode extends OrderNode {
+	next?: FloatingLimitOrderNode;
+	previous?: FloatingLimitOrderNode;
+
+	getSortValue(order: Order): BN {
+		return new BN(order.oraclePriceOffset);
+	}
+}
+
+export class MarketOrderNode extends OrderNode {
+	next?: MarketOrderNode;
+	previous?: MarketOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.slot;
+	}
+}
+
+export class TriggerOrderNode extends OrderNode {
+	next?: TriggerOrderNode;
+	previous?: TriggerOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.triggerPrice;
+	}
+}
+
+// We'll use the swift uuid for the order id since it's not yet on-chain
+export class SwiftOrderNode extends OrderNode {
+	next?: SwiftOrderNode;
+	previous?: SwiftOrderNode;
+
+	constructor(order: Order, userAccount: string) {
+		super(order, userAccount, true);
+	}
+
+	getSortValue(order: Order): BN {
+		return order.slot;
+	}
+}
+
+export type DLOBNodeMap = {
+	restingLimit: RestingLimitOrderNode;
+	takingLimit: TakingLimitOrderNode;
+	floatingLimit: FloatingLimitOrderNode;
+	market: MarketOrderNode;
+	trigger: TriggerOrderNode;
+	swift: SwiftOrderNode;
+};
+
+export type DLOBNodeType =
+	| 'swift'
+	| 'restingLimit'
+	| 'takingLimit'
+	| 'floatingLimit'
+	| 'market'
+	| ('trigger' & keyof DLOBNodeMap);
+
+export function createNode<T extends DLOBNodeType>(
+	nodeType: T,
+	order: Order,
+	userAccount: string,
+	isUserProtectedMaker: boolean
+): DLOBNodeMap[T] {
+	switch (nodeType) {
+		case 'floatingLimit':
+			return new FloatingLimitOrderNode(
+				order,
+				userAccount,
+				isUserProtectedMaker
+			);
+		case 'restingLimit':
+			return new RestingLimitOrderNode(
+				order,
+				userAccount,
+				isUserProtectedMaker
+			);
+		case 'takingLimit':
+			return new TakingLimitOrderNode(order, userAccount, isUserProtectedMaker);
+		case 'market':
+			return new MarketOrderNode(order, userAccount, isUserProtectedMaker);
+		case 'trigger':
+			return new TriggerOrderNode(order, userAccount, isUserProtectedMaker);
+		case 'swift':
+			return new SwiftOrderNode(order, userAccount);
+		default:
+			throw Error(`Unknown DLOBNode type ${nodeType}`);
+	}
+}

package/src/dlob/DLOBSubscriber.ts

@@ -0,0 +1,201 @@
+import { DLOB } from './DLOB';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import {
+	DLOBSource,
+	DLOBSubscriberEvents,
+	DLOBSubscriptionConfig,
+	SlotSource,
+} from './types';
+import { DriftClient } from '../driftClient';
+import { isVariant, MarketType } from '../types';
+import {
+	DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
+	getVammL2Generator,
+	L2OrderBook,
+	L2OrderBookGenerator,
+	L3OrderBook,
+} from './orderBookLevels';
+
+export class DLOBSubscriber {
+	driftClient: DriftClient;
+	dlobSource: DLOBSource;
+	slotSource: SlotSource;
+	updateFrequency: number;
+	intervalId?: NodeJS.Timeout;
+	dlob = new DLOB();
+	public eventEmitter: StrictEventEmitter<EventEmitter, DLOBSubscriberEvents>;
+
+	constructor(config: DLOBSubscriptionConfig) {
+		this.driftClient = config.driftClient;
+		this.dlobSource = config.dlobSource;
+		this.slotSource = config.slotSource;
+		this.updateFrequency = config.updateFrequency;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		await this.updateDLOB();
+
+		this.intervalId = setInterval(async () => {
+			try {
+				await this.updateDLOB();
+				this.eventEmitter.emit('update', this.dlob);
+			} catch (e) {
+				this.eventEmitter.emit('error', e);
+			}
+		}, this.updateFrequency);
+	}
+
+	async updateDLOB(): Promise<void> {
+		this.dlob = await this.dlobSource.getDLOB(this.slotSource.getSlot());
+	}
+
+	public getDLOB(): DLOB {
+		return this.dlob;
+	}
+
+	/**
+	 * Get the L2 order book for a given market.
+	 *
+	 * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+	 * @param marketIndex
+	 * @param marketType
+	 * @param depth Number of orders to include in the order book. Defaults to 10.
+	 * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+	 * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+	 */
+	public getL2({
+		marketName,
+		marketIndex,
+		marketType,
+		depth = 10,
+		includeVamm = false,
+		numVammOrders,
+		fallbackL2Generators = [],
+	}: {
+		marketName?: string;
+		marketIndex?: number;
+		marketType?: MarketType;
+		depth?: number;
+		includeVamm?: boolean;
+		numVammOrders?: number;
+		fallbackL2Generators?: L2OrderBookGenerator[];
+	}): L2OrderBook {
+		if (marketName) {
+			const derivedMarketInfo =
+				this.driftClient.getMarketIndexAndType(marketName);
+			if (!derivedMarketInfo) {
+				throw new Error(`Market ${marketName} not found`);
+			}
+			marketIndex = derivedMarketInfo.marketIndex;
+			marketType = derivedMarketInfo.marketType;
+		} else {
+			if (marketIndex === undefined || marketType === undefined) {
+				throw new Error(
+					'Either marketName or marketIndex and marketType must be provided'
+				);
+			}
+		}
+
+		let oraclePriceData;
+		const isPerp = isVariant(marketType, 'perp');
+		if (isPerp) {
+			const perpMarketAccount =
+				this.driftClient.getPerpMarketAccount(marketIndex);
+			oraclePriceData = this.driftClient.getOracleDataForPerpMarket(
+				perpMarketAccount.marketIndex
+			);
+		} else {
+			oraclePriceData =
+				this.driftClient.getOracleDataForSpotMarket(marketIndex);
+		}
+
+		if (isPerp && includeVamm) {
+			if (fallbackL2Generators.length > 0) {
+				throw new Error(
+					'includeVamm can only be used if fallbackL2Generators is empty'
+				);
+			}
+
+			fallbackL2Generators = [
+				getVammL2Generator({
+					marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
+					oraclePriceData,
+					numOrders: numVammOrders ?? depth,
+					topOfBookQuoteAmounts: DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
+				}),
+			];
+		}
+
+		return this.dlob.getL2({
+			marketIndex,
+			marketType,
+			depth,
+			oraclePriceData,
+			slot: this.slotSource.getSlot(),
+			fallbackL2Generators: fallbackL2Generators,
+		});
+	}
+
+	/**
+	 * Get the L3 order book for a given market.
+	 *
+	 * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+	 * @param marketIndex
+	 * @param marketType
+	 */
+	public getL3({
+		marketName,
+		marketIndex,
+		marketType,
+	}: {
+		marketName?: string;
+		marketIndex?: number;
+		marketType?: MarketType;
+	}): L3OrderBook {
+		if (marketName) {
+			const derivedMarketInfo =
+				this.driftClient.getMarketIndexAndType(marketName);
+			if (!derivedMarketInfo) {
+				throw new Error(`Market ${marketName} not found`);
+			}
+			marketIndex = derivedMarketInfo.marketIndex;
+			marketType = derivedMarketInfo.marketType;
+		} else {
+			if (marketIndex === undefined || marketType === undefined) {
+				throw new Error(
+					'Either marketName or marketIndex and marketType must be provided'
+				);
+			}
+		}
+
+		let oraclePriceData;
+		const isPerp = isVariant(marketType, 'perp');
+		if (isPerp) {
+			oraclePriceData =
+				this.driftClient.getOracleDataForPerpMarket(marketIndex);
+		} else {
+			oraclePriceData =
+				this.driftClient.getOracleDataForSpotMarket(marketIndex);
+		}
+
+		return this.dlob.getL3({
+			marketIndex,
+			marketType,
+			oraclePriceData,
+			slot: this.slotSource.getSlot(),
+		});
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/dlob/NodeList.ts

@@ -0,0 +1,173 @@
+import { isVariant, MarketTypeStr, Order } from '..';
+import { createNode, DLOBNode, DLOBNodeMap } from './DLOBNode';
+
+export type SortDirection = 'asc' | 'desc';
+
+export function getOrderSignature(
+	orderId: number,
+	userAccount: string
+): string {
+	return `${userAccount.toString()}-${orderId.toString()}`;
+}
+
+export interface DLOBNodeGenerator {
+	getGenerator(): Generator<DLOBNode>;
+}
+
+export class NodeList<NodeType extends keyof DLOBNodeMap>
+	implements DLOBNodeGenerator
+{
+	head?: DLOBNodeMap[NodeType];
+	length = 0;
+	nodeMap = new Map<string, DLOBNodeMap[NodeType]>();
+
+	constructor(
+		private nodeType: NodeType,
+		private sortDirection: SortDirection
+	) {}
+
+	public clear() {
+		this.head = undefined;
+		this.length = 0;
+		this.nodeMap.clear();
+	}
+
+	public insert(
+		order: Order,
+		marketType: MarketTypeStr,
+		userAccount: string,
+		isUserProtectedMaker: boolean
+	): void {
+		if (isVariant(order.status, 'init')) {
+			return;
+		}
+
+		const newNode = createNode(
+			this.nodeType,
+			order,
+			userAccount,
+			isUserProtectedMaker
+		);
+
+		const orderSignature = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderSignature)) {
+			return;
+		}
+		this.nodeMap.set(orderSignature, newNode);
+
+		this.length += 1;
+
+		if (this.head === undefined) {
+			this.head = newNode;
+			return;
+		}
+
+		if (this.prependNode(this.head, newNode)) {
+			this.head.previous = newNode;
+			newNode.next = this.head;
+			this.head = newNode;
+			return;
+		}
+
+		let currentNode = this.head;
+		while (
+			currentNode.next !== undefined &&
+			!this.prependNode(currentNode.next, newNode)
+		) {
+			currentNode = currentNode.next;
+		}
+
+		newNode.next = currentNode.next;
+		if (currentNode.next !== undefined) {
+			newNode.next.previous = newNode;
+		}
+		currentNode.next = newNode;
+		newNode.previous = currentNode;
+	}
+
+	prependNode(
+		currentNode: DLOBNodeMap[NodeType],
+		newNode: DLOBNodeMap[NodeType]
+	): boolean {
+		const currentOrder = currentNode.order;
+		const newOrder = newNode.order;
+
+		const currentOrderSortPrice = currentNode.sortValue;
+		const newOrderSortPrice = newNode.sortValue;
+
+		if (newOrderSortPrice.eq(currentOrderSortPrice)) {
+			return newOrder.slot.lt(currentOrder.slot);
+		}
+
+		if (this.sortDirection === 'asc') {
+			return newOrderSortPrice.lt(currentOrderSortPrice);
+		} else {
+			return newOrderSortPrice.gt(currentOrderSortPrice);
+		}
+	}
+
+	public update(order: Order, userAccount: string): void {
+		const orderId = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderId)) {
+			const node = this.nodeMap.get(orderId);
+			Object.assign(node.order, order);
+			node.haveFilled = false;
+		}
+	}
+
+	public remove(order: Order, userAccount: string): void {
+		const orderId = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderId)) {
+			const node = this.nodeMap.get(orderId);
+			if (node.next) {
+				node.next.previous = node.previous;
+			}
+			if (node.previous) {
+				node.previous.next = node.next;
+			}
+
+			if (this.head && node.order.orderId === this.head.order.orderId) {
+				this.head = node.next;
+			}
+
+			node.previous = undefined;
+			node.next = undefined;
+
+			this.nodeMap.delete(orderId);
+
+			this.length--;
+		}
+	}
+
+	*getGenerator(): Generator<DLOBNode> {
+		let node = this.head;
+		while (node !== undefined) {
+			yield node;
+			node = node.next;
+		}
+	}
+
+	public has(order: Order, userAccount: string): boolean {
+		return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+	}
+
+	public get(orderSignature: string): DLOBNodeMap[NodeType] | undefined {
+		return this.nodeMap.get(orderSignature);
+	}
+
+	public print(): void {
+		let currentNode = this.head;
+		while (currentNode !== undefined) {
+			console.log(currentNode.getLabel());
+			currentNode = currentNode.next;
+		}
+	}
+
+	public printTop(): void {
+		if (this.head) {
+			console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+		} else {
+			console.log('---');
+		}
+	}
+}