@drift-labs/sdk 0.2.0-master.26 → 0.2.0-master.27

package/src/dlob/DLOBNode.ts

@@ -0,0 +1,163 @@
+import {
+	isOneOfVariant,
+	AMM_RESERVE_PRECISION,
+	BN,
+	convertToNumber,
+	getLimitPrice,
+	isVariant,
+	SpotMarketAccount,
+	PerpMarketAccount,
+	MARK_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;
+	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,
+				MARK_PRICE_PRECISION
+			).toFixed(3)}`;
+		}
+		if (this.order.triggerPrice.gt(ZERO)) {
+			msg += ` ${
+				isVariant(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'
+			}`;
+			msg += ` ${convertToNumber(
+				this.order.triggerPrice,
+				MARK_PRICE_PRECISION
+			).toFixed(3)}`;
+		}
+		return msg;
+	}
+
+	getPrice(oraclePriceData: OraclePriceData, slot: number): BN {
+		if (isOneOfVariant(this.order.marketType, ['spot'])) {
+			return getLimitPrice(this.order, oraclePriceData, slot);
+		} else if (isOneOfVariant(this.order.marketType, ['perp'])) {
+			return getLimitPrice(
+				this.order,
+				oraclePriceData,
+				slot,
+				this.market as PerpMarketAccount
+			);
+		} else {
+			console.error(`Unknown market type: ${this.order.marketType}`);
+		}
+	}
+
+	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 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,185 @@
+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: BN, 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 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 orderId = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderId)) {
+			return;
+		}
+		this.nodeMap.set(orderId, 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.ts.lt(currentOrder.ts);
+		}
+
+		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.eq(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,
+		haveFilled: false,
+	};
+}

package/src/events/eventList.js

@@ -1,52 +1,24 @@
 "use strict";
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventList = void 0;
-var Node = /** @class */ (function () {
-    function Node(event, next, prev) {
+class Node {
+    constructor(event, next, prev) {
         this.event = event;
         this.next = next;
         this.prev = prev;
     }
-    return Node;
-}());
-var EventList = /** @class */ (function () {
-    function EventList(eventType, maxSize, sortFn, orderDirection) {
+}
+class EventList {
+    constructor(eventType, maxSize, sortFn, orderDirection) {
         this.eventType = eventType;
         this.maxSize = maxSize;
         this.sortFn = sortFn;
         this.orderDirection = orderDirection;
         this.size = 0;
     }
-    EventList.prototype.insert = function (event) {
+    insert(event) {
         this.size++;
-        var newNode = new Node(event);
+        const newNode = new Node(event);
         if (this.head === undefined) {
             this.head = this.tail = newNode;
             return;
@@ -58,7 +30,7 @@ var EventList = /** @class */ (function () {
             this.head = newNode;
         }
         else {
-            var currentNode = this.head;
+            let currentNode = this.head;
             while (currentNode.next !== undefined &&
                 this.sortFn(currentNode.next.event, newNode.event) !==
                     (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
@@ -68,18 +40,15 @@ var EventList = /** @class */ (function () {
             if (currentNode.next !== undefined) {
                 newNode.next.prev = newNode;
             }
-            else {
-                this.tail = newNode;
-            }
             currentNode.next = newNode;
             newNode.prev = currentNode;
         }
         if (this.size > this.maxSize) {
             this.detach();
         }
-    };
-    EventList.prototype.detach = function () {
-        var node = this.tail;
+    }
+    detach() {
+        const node = this.tail;
         if (node.prev !== undefined) {
             node.prev.next = node.next;
         }
@@ -93,28 +62,16 @@ var EventList = /** @class */ (function () {
             this.tail = node.prev;
         }
         this.size--;
-    };
-    EventList.prototype.toArray = function () {
+    }
+    toArray() {
         return Array.from(this);
-    };
-    EventList.prototype[Symbol.iterator] = function () {
-        var node;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    node = this.head;
-                    _a.label = 1;
-                case 1:
-                    if (!node) return [3 /*break*/, 3];
-                    return [4 /*yield*/, node.event];
-                case 2:
-                    _a.sent();
-                    node = node.next;
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/];
-            }
-        });
-    };
-    return EventList;
-}());
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.event;
+            node = node.next;
+        }
+    }
+}
 exports.EventList = EventList;

package/src/events/txEventCache.js

@@ -1,25 +1,23 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxEventCache = void 0;
-var Node = /** @class */ (function () {
-    function Node(key, value, next, prev) {
+class Node {
+    constructor(key, value, next, prev) {
         this.key = key;
         this.value = value;
         this.next = next;
         this.prev = prev;
     }
-    return Node;
-}());
+}
 // lru cache
-var TxEventCache = /** @class */ (function () {
-    function TxEventCache(maxTx) {
-        if (maxTx === void 0) { maxTx = 1024; }
+class TxEventCache {
+    constructor(maxTx = 1024) {
         this.maxTx = maxTx;
         this.size = 0;
         this.cacheMap = {};
     }
-    TxEventCache.prototype.add = function (key, events) {
-        var existingNode = this.cacheMap[key];
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
         if (existingNode) {
             this.detach(existingNode);
             this.size--;
@@ -34,22 +32,22 @@ var TxEventCache = /** @class */ (function () {
             this.head = this.tail = new Node(key, events);
         }
         else {
-            var node = new Node(key, events, this.head);
+            const node = new Node(key, events, this.head);
             this.head.prev = node;
             this.head = node;
         }
         // update cacheMap with LinkedList key and Node reference
         this.cacheMap[key] = this.head;
         this.size++;
-    };
-    TxEventCache.prototype.has = function (key) {
+    }
+    has(key) {
         return this.cacheMap.hasOwnProperty(key);
-    };
-    TxEventCache.prototype.get = function (key) {
+    }
+    get(key) {
         var _a;
         return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
-    };
-    TxEventCache.prototype.detach = function (node) {
+    }
+    detach(node) {
         if (node.prev !== undefined) {
             node.prev.next = node.next;
         }
@@ -62,13 +60,12 @@ var TxEventCache = /** @class */ (function () {
         else {
             this.tail = node.prev;
         }
-    };
-    TxEventCache.prototype.clear = function () {
+    }
+    clear() {
         this.head = undefined;
         this.tail = undefined;
         this.size = 0;
         this.cacheMap = {};
-    };
-    return TxEventCache;
-}());
+    }
+}
 exports.TxEventCache = TxEventCache;