@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/src/dlob/DLOBNode.ts

@@ -0,0 +1,167 @@
+import {
+	isOneOfVariant,
+	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 {
+		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}`);
+		}
+	}
+
+	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 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,189 @@
+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 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.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 === 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,
+	};
+}

package/src/events/eventList.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventList = void 0;
+class Node {
+    constructor(event, next, prev) {
+        this.event = event;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+class EventList {
+    constructor(eventType, maxSize, sortFn, orderDirection) {
+        this.eventType = eventType;
+        this.maxSize = maxSize;
+        this.sortFn = sortFn;
+        this.orderDirection = orderDirection;
+        this.size = 0;
+    }
+    insert(event) {
+        this.size++;
+        const newNode = new Node(event);
+        if (this.head === undefined) {
+            this.head = this.tail = newNode;
+            return;
+        }
+        if (this.sortFn(this.head.event, newNode.event) ===
+            (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+            this.head.prev = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+        }
+        else {
+            let currentNode = this.head;
+            while (currentNode.next !== undefined &&
+                this.sortFn(currentNode.next.event, newNode.event) !==
+                    (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+                currentNode = currentNode.next;
+            }
+            newNode.next = currentNode.next;
+            if (currentNode.next !== undefined) {
+                newNode.next.prev = newNode;
+            }
+            currentNode.next = newNode;
+            newNode.prev = currentNode;
+        }
+        if (this.size > this.maxSize) {
+            this.detach();
+        }
+    }
+    detach() {
+        const node = this.tail;
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+        this.size--;
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.event;
+            node = node.next;
+        }
+    }
+}
+exports.EventList = EventList;

package/src/events/eventList.ts

@@ -53,7 +53,10 @@ export class EventList<Type extends EventType> {
 			newNode.next = currentNode.next;
 			if (currentNode.next !== undefined) {
 				newNode.next.prev = newNode;
+			} else {
+				this.tail = newNode;
 			}
+
 			currentNode.next = newNode;
 			newNode.prev = currentNode;
 		}

package/src/events/eventSubscriber.ts

@@ -25,6 +25,8 @@ export class EventSubscriber {
 	private awaitTxResolver = new Map<string, () => void>();
 	private logProvider: LogProvider;
 	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+	private lastSeenSlot: number;
+	public lastSeenTxSig: string;
 
 	public constructor(
 		private connection: Connection,
@@ -62,19 +64,22 @@ export class EventSubscriber {
 		}
 	}
 
-	public subscribe(): boolean {
-		if (this.logProvider.isSubscribed()) {
-			return true;
-		}
+	public async subscribe(): Promise<boolean> {
+		try {
+			if (this.logProvider.isSubscribed()) {
+				return true;
+			}
 
-		this.fetchPreviousTx().catch((e) => {
+			this.logProvider.subscribe((txSig, slot, logs) => {
+				this.handleTxLogs(txSig, slot, logs);
+			}, true);
+
+			return true;
+		} catch (e) {
 			console.error('Error fetching previous txs in event subscriber');
 			console.error(e);
-		});
-
-		return this.logProvider.subscribe((txSig, slot, logs) => {
-			this.handleTxLogs(txSig, slot, logs);
-		});
+			return false;
+		}
 	}
 
 	private handleTxLogs(
@@ -98,11 +103,14 @@ export class EventSubscriber {
 			this.awaitTxResolver.delete(txSig);
 		}
 
+		if (slot > this.lastSeenSlot) {
+			this.lastSeenTxSig = txSig;
+		}
 		this.txEventCache.add(txSig, wrappedEvents);
 	}
 
-	private async fetchPreviousTx(): Promise<void> {
-		if (!this.options.untilTx) {
+	public async fetchPreviousTx(fetchMax?: boolean): Promise<void> {
+		if (!this.options.untilTx && !fetchMax) {
 			return;
 		}
 

package/src/events/fetchLogs.ts

@@ -1,14 +1,18 @@
+import { Program } from '@project-serum/anchor';
 import {
 	Connection,
 	Finality,
 	PublicKey,
 	TransactionSignature,
 } from '@solana/web3.js';
+import { WrappedEvents } from './types';
 
 type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
 type FetchLogsResponse = {
 	earliestTx: string;
 	mostRecentTx: string;
+	earliestSlot: number;
+	mostRecentSlot: number;
 	transactionLogs: Log[];
 };
 
@@ -17,19 +21,21 @@ export async function fetchLogs(
 	programId: PublicKey,
 	finality: Finality,
 	beforeTx?: TransactionSignature,
-	untilTx?: TransactionSignature
-): Promise<FetchLogsResponse | undefined> {
+	untilTx?: TransactionSignature,
+	limit?: number
+): Promise<FetchLogsResponse> {
 	const signatures = await connection.getSignaturesForAddress(
 		programId,
 		{
 			before: beforeTx,
 			until: untilTx,
+			limit,
 		},
 		finality
 	);
 
 	const sortedSignatures = signatures.sort((a, b) =>
-		a.slot < b.slot ? -1 : 1
+		a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1
 	);
 
 	const filteredSignatures = sortedSignatures.filter(
@@ -61,14 +67,15 @@ export async function fetchLogs(
 		)
 	).flat();
 
-	const earliestTx = filteredSignatures[0].signature;
-	const mostRecentTx =
-		filteredSignatures[filteredSignatures.length - 1].signature;
+	const earliest = filteredSignatures[0];
+	const mostRecent = filteredSignatures[filteredSignatures.length - 1];
 
 	return {
 		transactionLogs: transactionLogs,
-		earliestTx: earliestTx,
-		mostRecentTx: mostRecentTx,
+		earliestTx: earliest.signature,
+		mostRecentTx: mostRecent.signature,
+		earliestSlot: earliest.slot,
+		mostRecentSlot: mostRecent.slot,
 	};
 }
 
@@ -78,3 +85,23 @@ function chunk<T>(array: readonly T[], size: number): T[][] {
 		.map((_, index) => index * size)
 		.map((begin) => array.slice(begin, begin + size));
 }
+
+export class LogParser {
+	private program: Program;
+
+	constructor(program: Program) {
+		this.program = program;
+	}
+
+	public parseEventsFromLogs(event: Log): WrappedEvents {
+		const records: WrappedEvents = [];
+		// @ts-ignore
+		this.program._events._eventParser.parseLogs(event.logs, (eventLog) => {
+			eventLog.data.txSig = event.txSig;
+			eventLog.data.slot = event.slot;
+			eventLog.data.eventType = eventLog.name;
+			records.push(eventLog.data);
+		});
+		return records;
+	}
+}

package/src/events/pollingLogProvider.ts

@@ -13,6 +13,7 @@ export class PollingLogProvider implements LogProvider {
 	private intervalId: NodeJS.Timer;
 	private mostRecentSeenTx?: TransactionSignature;
 	private mutex: number;
+	private firstFetch = true;
 
 	public constructor(
 		private connection: Connection,
@@ -23,7 +24,10 @@ export class PollingLogProvider implements LogProvider {
 		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
 	}
 
-	public subscribe(callback: logProviderCallback): boolean {
+	public subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): boolean {
 		if (this.intervalId) {
 			return true;
 		}
@@ -40,9 +44,13 @@ export class PollingLogProvider implements LogProvider {
 					this.programId,
 					this.finality,
 					undefined,
-					this.mostRecentSeenTx
+					this.mostRecentSeenTx,
+					// If skipping history, only fetch one log back, not the maximum amount available
+					skipHistory && this.firstFetch ? 1 : undefined
 				);
 
+				this.firstFetch = false;
+
 				if (response === undefined) {
 					return;
 				}

package/src/events/sort.ts

@@ -6,8 +6,8 @@ import {
 	SortFn,
 	Event,
 } from './types';
-import { OrderRecord } from '../types';
-import { PublicKey, ZERO } from '../index';
+import { OrderActionRecord } from '../types';
+import { ZERO } from '../index';
 
 function clientSortAscFn(): 'less than' {
 	return 'less than';
@@ -24,21 +24,17 @@ function defaultBlockchainSortFn(
 	return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
 }
 
-function orderRecordSortFn(
-	currentEvent: Event<OrderRecord>,
-	newEvent: Event<OrderRecord>
+function orderActionRecordSortFn(
+	currentEvent: Event<OrderActionRecord>,
+	newEvent: Event<OrderActionRecord>
 ): 'less than' | 'greater than' {
-	const currentEventMarketIndex = !currentEvent.maker.equals(PublicKey.default)
-		? currentEvent.makerOrder.marketIndex
-		: currentEvent.takerOrder.marketIndex;
-	const newEventMarketIndex = !newEvent.maker.equals(PublicKey.default)
-		? newEvent.makerOrder.marketIndex
-		: newEvent.takerOrder.marketIndex;
-	if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+	const currentEventMarketIndex = currentEvent.marketIndex;
+	const newEventMarketIndex = newEvent.marketIndex;
+	if (currentEventMarketIndex !== newEventMarketIndex) {
 		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
 	}
 
-	if (currentEvent.fillRecordId.gt(ZERO) && newEvent.fillRecordId.gt(ZERO)) {
+	if (currentEvent.fillRecordId?.gt(ZERO) && newEvent.fillRecordId?.gt(ZERO)) {
 		return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
 			? 'less than'
 			: 'greater than';
@@ -57,8 +53,8 @@ export function getSortFn(
 	}
 
 	switch (eventType) {
-		case 'OrderRecord':
-			return orderRecordSortFn;
+		case 'OrderActionRecord':
+			return orderActionRecordSortFn;
 		default:
 			return defaultBlockchainSortFn;
 	}