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

package/lib/dlob/NodeList.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="bn.js" />
+import { BN, MarketTypeStr, Order, PerpMarketAccount, SpotMarketAccount } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { DLOBNode, DLOBNodeMap } from './DLOBNode';
+export declare type SortDirection = 'asc' | 'desc';
+export declare function getOrderSignature(orderId: BN, userAccount: PublicKey): string;
+export interface DLOBNodeGenerator {
+    getGenerator(): Generator<DLOBNode>;
+}
+export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLOBNodeGenerator {
+    private nodeType;
+    private sortDirection;
+    head?: DLOBNodeMap[NodeType];
+    length: number;
+    nodeMap: Map<string, DLOBNodeMap[NodeType]>;
+    constructor(nodeType: NodeType, sortDirection: SortDirection);
+    insert(order: Order, marketType: MarketTypeStr, market: PerpMarketAccount | SpotMarketAccount, userAccount: PublicKey): void;
+    prependNode(currentNode: DLOBNodeMap[NodeType], newNode: DLOBNodeMap[NodeType]): boolean;
+    update(order: Order, userAccount: PublicKey): void;
+    remove(order: Order, userAccount: PublicKey): void;
+    getGenerator(): Generator<DLOBNode>;
+    has(order: Order, userAccount: PublicKey): boolean;
+    print(): void;
+    printTop(): void;
+}
+export declare function getVammNodeGenerator(price: BN | undefined): Generator<DLOBNode>;

package/lib/dlob/NodeList.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVammNodeGenerator = exports.NodeList = exports.getOrderSignature = void 0;
+const __1 = require("..");
+const DLOBNode_1 = require("./DLOBNode");
+function getOrderSignature(orderId, userAccount) {
+    return `${userAccount.toString()}-${orderId.toString()}`;
+}
+exports.getOrderSignature = getOrderSignature;
+class NodeList {
+    constructor(nodeType, sortDirection) {
+        this.nodeType = nodeType;
+        this.sortDirection = sortDirection;
+        this.length = 0;
+        this.nodeMap = new Map();
+    }
+    insert(order, marketType, market, userAccount) {
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        if (marketType === 'spot') {
+            market = market;
+        }
+        else if (marketType === 'perp') {
+            market = market;
+        }
+        const newNode = (0, DLOBNode_1.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, newNode) {
+        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);
+        }
+    }
+    update(order, userAccount) {
+        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;
+        }
+    }
+    remove(order, userAccount) {
+        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() {
+        let node = this.head;
+        while (node !== undefined) {
+            yield node;
+            node = node.next;
+        }
+    }
+    has(order, userAccount) {
+        return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+    }
+    print() {
+        let currentNode = this.head;
+        while (currentNode !== undefined) {
+            console.log(currentNode.getLabel());
+            currentNode = currentNode.next;
+        }
+    }
+    printTop() {
+        if (this.head) {
+            console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+        }
+        else {
+            console.log('---');
+        }
+    }
+}
+exports.NodeList = NodeList;
+function* getVammNodeGenerator(price) {
+    if (!price) {
+        return;
+    }
+    yield {
+        getPrice: () => price,
+        isVammNode: () => true,
+        order: undefined,
+        market: undefined,
+        userAccount: undefined,
+        haveFilled: false,
+    };
+}
+exports.getVammNodeGenerator = getVammNodeGenerator;