@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.41

package/src/dlob/DLOBNode.ts

@@ -0,0 +1,155 @@
+import {
+	AMM_RESERVE_PRECISION,
+	BN,
+	convertToNumber,
+	getLimitPrice,
+	isVariant,
+	SpotMarketAccount,
+	PerpMarketAccount,
+	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: 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
+	) {
+		this.order = order;
+		this.market = market;
+		this.userAccount = userAccount;
+		this.sortValue = this.getSortValue(order);
+	}
+
+	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 LimitOrderNode extends OrderNode {
+	next?: LimitOrderNode;
+	previous?: LimitOrderNode;
+
+	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;
+	}
+}
+
+export type DLOBNodeMap = {
+	limit: LimitOrderNode;
+	floatingLimit: FloatingLimitOrderNode;
+	market: MarketOrderNode;
+	trigger: TriggerOrderNode;
+};
+
+export type DLOBNodeType =
+	| 'limit'
+	| 'floatingLimit'
+	| 'market'
+	| ('trigger' & keyof DLOBNodeMap);
+
+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);
+		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}`);
+	}
+}

package/src/dlob/NodeList.ts

@@ -0,0 +1,195 @@
+import {
+	BN,
+	isVariant,
+	MarketTypeStr,
+	Order,
+	PerpMarketAccount,
+	SpotMarketAccount,
+} from '..';
+import { PublicKey } from '@solana/web3.js';
+import { createNode, DLOBNode, DLOBNodeMap } from './DLOBNode';
+
+export type SortDirection = 'asc' | 'desc';
+
+export function getOrderSignature(
+	orderId: number,
+	userAccount: PublicKey
+): 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,
+		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 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: PublicKey): 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: PublicKey): 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: PublicKey): boolean {
+		return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+	}
+
+	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('---');
+		}
+	}
+}
+
+export function* getVammNodeGenerator(
+	price: BN | undefined
+): Generator<DLOBNode> {
+	if (!price) {
+		return;
+	}
+	yield {
+		getPrice: () => price,
+		isVammNode: () => true,
+		order: undefined,
+		market: undefined,
+		userAccount: undefined,
+		isBaseFilled: () => false,
+		haveFilled: false,
+	};
+}