@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/events/eventSubscriber.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriber = void 0;
+const types_1 = require("./types");
+const txEventCache_1 = require("./txEventCache");
+const eventList_1 = require("./eventList");
+const pollingLogProvider_1 = require("./pollingLogProvider");
+const fetchLogs_1 = require("./fetchLogs");
+const webSocketLogProvider_1 = require("./webSocketLogProvider");
+const events_1 = require("events");
+const sort_1 = require("./sort");
+class EventSubscriber {
+    constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
+        this.connection = connection;
+        this.program = program;
+        this.options = options;
+        this.awaitTxPromises = new Map();
+        this.awaitTxResolver = new Map();
+        this.options = Object.assign({}, types_1.DefaultEventSubscriptionOptions, options);
+        this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
+        this.eventListMap = new Map();
+        for (const eventType of this.options.eventTypes) {
+            this.eventListMap.set(eventType, new eventList_1.EventList(eventType, this.options.maxEventsPerType, sort_1.getSortFn(this.options.orderBy, this.options.orderDir, eventType), this.options.orderDir));
+        }
+        this.eventEmitter = new events_1.EventEmitter();
+        if (this.options.logProviderConfig.type === 'websocket') {
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.program.programId, this.options.commitment);
+        }
+        else {
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.program.programId, options.commitment, this.options.logProviderConfig.frequency);
+        }
+    }
+    subscribe() {
+        if (this.logProvider.isSubscribed()) {
+            return true;
+        }
+        this.fetchPreviousTx().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);
+        });
+    }
+    handleTxLogs(txSig, slot, logs) {
+        if (this.txEventCache.has(txSig)) {
+            return;
+        }
+        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+        for (const wrappedEvent of wrappedEvents) {
+            this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+            this.eventEmitter.emit('newEvent', wrappedEvent);
+        }
+        if (this.awaitTxPromises.has(txSig)) {
+            this.awaitTxPromises.delete(txSig);
+            this.awaitTxResolver.get(txSig)();
+            this.awaitTxResolver.delete(txSig);
+        }
+        this.txEventCache.add(txSig, wrappedEvents);
+    }
+    fetchPreviousTx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.untilTx) {
+                return;
+            }
+            let txFetched = 0;
+            let beforeTx = undefined;
+            const untilTx = this.options.untilTx;
+            while (txFetched < this.options.maxTx) {
+                const response = yield fetchLogs_1.fetchLogs(this.connection, this.program.programId, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+                if (response === undefined) {
+                    break;
+                }
+                txFetched += response.transactionLogs.length;
+                beforeTx = response.earliestTx;
+                for (const { txSig, slot, logs } of response.transactionLogs) {
+                    this.handleTxLogs(txSig, slot, logs);
+                }
+            }
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.logProvider.unsubscribe();
+        });
+    }
+    parseEventsFromLogs(txSig, slot, logs) {
+        const records = [];
+        // @ts-ignore
+        this.program._events._eventParser.parseLogs(logs, (event) => {
+            const expectRecordType = this.eventListMap.has(event.name);
+            if (expectRecordType) {
+                event.data.txSig = txSig;
+                event.data.slot = slot;
+                event.data.eventType = event.name;
+                records.push(event.data);
+            }
+        });
+        return records;
+    }
+    awaitTx(txSig) {
+        if (this.awaitTxPromises.has(txSig)) {
+            return this.awaitTxPromises.get(txSig);
+        }
+        if (this.txEventCache.has(txSig)) {
+            return Promise.resolve();
+        }
+        const promise = new Promise((resolve) => {
+            this.awaitTxResolver.set(txSig, resolve);
+        });
+        this.awaitTxPromises.set(txSig, promise);
+        return promise;
+    }
+    getEventList(eventType) {
+        return this.eventListMap.get(eventType);
+    }
+    /**
+     * This requires the EventList be cast to an array, which requires reallocation of memory.
+     * Would bias to using getEventList over getEvents
+     *
+     * @param eventType
+     */
+    getEventsArray(eventType) {
+        return this.eventListMap.get(eventType).toArray();
+    }
+    getEventsByTx(txSig) {
+        return this.txEventCache.get(txSig);
+    }
+}
+exports.EventSubscriber = EventSubscriber;

package/src/events/eventSubscriber.ts

@@ -0,0 +1,194 @@
+import { Connection, TransactionSignature } from '@solana/web3.js';
+import { Program } from '@project-serum/anchor';
+import {
+	DefaultEventSubscriptionOptions,
+	EventSubscriptionOptions,
+	EventType,
+	WrappedEvents,
+	EventMap,
+	LogProvider,
+	EventSubscriberEvents,
+} from './types';
+import { TxEventCache } from './txEventCache';
+import { EventList } from './eventList';
+import { PollingLogProvider } from './pollingLogProvider';
+import { fetchLogs } from './fetchLogs';
+import { WebSocketLogProvider } from './webSocketLogProvider';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { getSortFn } from './sort';
+
+export class EventSubscriber {
+	private eventListMap: Map<EventType, EventList<EventType>>;
+	private txEventCache: TxEventCache;
+	private awaitTxPromises = new Map<string, Promise<void>>();
+	private awaitTxResolver = new Map<string, () => void>();
+	private logProvider: LogProvider;
+	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+
+	public constructor(
+		private connection: Connection,
+		private program: Program,
+		private options: EventSubscriptionOptions = DefaultEventSubscriptionOptions
+	) {
+		this.options = Object.assign({}, DefaultEventSubscriptionOptions, options);
+		this.txEventCache = new TxEventCache(this.options.maxTx);
+		this.eventListMap = new Map<EventType, EventList<EventType>>();
+		for (const eventType of this.options.eventTypes) {
+			this.eventListMap.set(
+				eventType,
+				new EventList(
+					eventType,
+					this.options.maxEventsPerType,
+					getSortFn(this.options.orderBy, this.options.orderDir, eventType),
+					this.options.orderDir
+				)
+			);
+		}
+		this.eventEmitter = new EventEmitter();
+		if (this.options.logProviderConfig.type === 'websocket') {
+			this.logProvider = new WebSocketLogProvider(
+				this.connection,
+				this.program.programId,
+				this.options.commitment
+			);
+		} else {
+			this.logProvider = new PollingLogProvider(
+				this.connection,
+				this.program.programId,
+				options.commitment,
+				this.options.logProviderConfig.frequency
+			);
+		}
+	}
+
+	public subscribe(): boolean {
+		if (this.logProvider.isSubscribed()) {
+			return true;
+		}
+
+		this.fetchPreviousTx().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);
+		});
+	}
+
+	private handleTxLogs(
+		txSig: TransactionSignature,
+		slot: number,
+		logs: string[]
+	): void {
+		if (this.txEventCache.has(txSig)) {
+			return;
+		}
+
+		const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+		for (const wrappedEvent of wrappedEvents) {
+			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+			this.eventEmitter.emit('newEvent', wrappedEvent);
+		}
+
+		if (this.awaitTxPromises.has(txSig)) {
+			this.awaitTxPromises.delete(txSig);
+			this.awaitTxResolver.get(txSig)();
+			this.awaitTxResolver.delete(txSig);
+		}
+
+		this.txEventCache.add(txSig, wrappedEvents);
+	}
+
+	private async fetchPreviousTx(): Promise<void> {
+		if (!this.options.untilTx) {
+			return;
+		}
+
+		let txFetched = 0;
+		let beforeTx: TransactionSignature = undefined;
+		const untilTx: TransactionSignature = this.options.untilTx;
+		while (txFetched < this.options.maxTx) {
+			const response = await fetchLogs(
+				this.connection,
+				this.program.programId,
+				this.options.commitment === 'finalized' ? 'finalized' : 'confirmed',
+				beforeTx,
+				untilTx
+			);
+
+			if (response === undefined) {
+				break;
+			}
+
+			txFetched += response.transactionLogs.length;
+			beforeTx = response.earliestTx;
+
+			for (const { txSig, slot, logs } of response.transactionLogs) {
+				this.handleTxLogs(txSig, slot, logs);
+			}
+		}
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		return await this.logProvider.unsubscribe();
+	}
+
+	private parseEventsFromLogs(
+		txSig: TransactionSignature,
+		slot: number,
+		logs: string[]
+	): WrappedEvents {
+		const records = [];
+		// @ts-ignore
+		this.program._events._eventParser.parseLogs(logs, (event) => {
+			const expectRecordType = this.eventListMap.has(event.name);
+			if (expectRecordType) {
+				event.data.txSig = txSig;
+				event.data.slot = slot;
+				event.data.eventType = event.name;
+				records.push(event.data);
+			}
+		});
+		return records;
+	}
+
+	public awaitTx(txSig: TransactionSignature): Promise<void> {
+		if (this.awaitTxPromises.has(txSig)) {
+			return this.awaitTxPromises.get(txSig);
+		}
+
+		if (this.txEventCache.has(txSig)) {
+			return Promise.resolve();
+		}
+
+		const promise = new Promise<void>((resolve) => {
+			this.awaitTxResolver.set(txSig, resolve);
+		});
+		this.awaitTxPromises.set(txSig, promise);
+		return promise;
+	}
+
+	public getEventList<Type extends keyof EventMap>(
+		eventType: Type
+	): EventList<Type> {
+		return this.eventListMap.get(eventType) as EventList<Type>;
+	}
+
+	/**
+	 * This requires the EventList be cast to an array, which requires reallocation of memory.
+	 * Would bias to using getEventList over getEvents
+	 *
+	 * @param eventType
+	 */
+	public getEventsArray<Type extends EventType>(
+		eventType: Type
+	): EventMap[Type][] {
+		return this.eventListMap.get(eventType).toArray() as EventMap[Type][];
+	}
+
+	public getEventsByTx(txSig: TransactionSignature): WrappedEvents | undefined {
+		return this.txEventCache.get(txSig);
+	}
+}

package/src/events/fetchLogs.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchLogs = void 0;
+function fetchLogs(connection, programId, finality, beforeTx, untilTx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const signatures = yield connection.getSignaturesForAddress(programId, {
+            before: beforeTx,
+            until: untilTx,
+        }, finality);
+        const sortedSignatures = signatures.sort((a, b) => a.slot < b.slot ? -1 : 1);
+        const filteredSignatures = sortedSignatures.filter((signature) => !signature.err);
+        if (filteredSignatures.length === 0) {
+            return undefined;
+        }
+        const chunkedSignatures = chunk(filteredSignatures, 100);
+        const transactionLogs = (yield Promise.all(chunkedSignatures.map((chunk) => __awaiter(this, void 0, void 0, function* () {
+            const transactions = yield connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), finality);
+            return transactions.map((transaction) => {
+                return {
+                    txSig: transaction.transaction.signatures[0],
+                    slot: transaction.slot,
+                    logs: transaction.meta.logMessages,
+                };
+            });
+        })))).flat();
+        const earliestTx = filteredSignatures[0].signature;
+        const mostRecentTx = filteredSignatures[filteredSignatures.length - 1].signature;
+        return {
+            transactionLogs: transactionLogs,
+            earliestTx: earliestTx,
+            mostRecentTx: mostRecentTx,
+        };
+    });
+}
+exports.fetchLogs = fetchLogs;
+function chunk(array, size) {
+    return new Array(Math.ceil(array.length / size))
+        .fill(null)
+        .map((_, index) => index * size)
+        .map((begin) => array.slice(begin, begin + size));
+}

package/src/events/fetchLogs.ts

@@ -0,0 +1,80 @@
+import {
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionSignature,
+} from '@solana/web3.js';
+
+type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
+type FetchLogsResponse = {
+	earliestTx: string;
+	mostRecentTx: string;
+	transactionLogs: Log[];
+};
+
+export async function fetchLogs(
+	connection: Connection,
+	programId: PublicKey,
+	finality: Finality,
+	beforeTx?: TransactionSignature,
+	untilTx?: TransactionSignature
+): Promise<FetchLogsResponse | undefined> {
+	const signatures = await connection.getSignaturesForAddress(
+		programId,
+		{
+			before: beforeTx,
+			until: untilTx,
+		},
+		finality
+	);
+
+	const sortedSignatures = signatures.sort((a, b) =>
+		a.slot < b.slot ? -1 : 1
+	);
+
+	const filteredSignatures = sortedSignatures.filter(
+		(signature) => !signature.err
+	);
+
+	if (filteredSignatures.length === 0) {
+		return undefined;
+	}
+
+	const chunkedSignatures = chunk(filteredSignatures, 100);
+
+	const transactionLogs = (
+		await Promise.all(
+			chunkedSignatures.map(async (chunk) => {
+				const transactions = await connection.getTransactions(
+					chunk.map((confirmedSignature) => confirmedSignature.signature),
+					finality
+				);
+
+				return transactions.map((transaction) => {
+					return {
+						txSig: transaction.transaction.signatures[0],
+						slot: transaction.slot,
+						logs: transaction.meta.logMessages,
+					};
+				});
+			})
+		)
+	).flat();
+
+	const earliestTx = filteredSignatures[0].signature;
+	const mostRecentTx =
+		filteredSignatures[filteredSignatures.length - 1].signature;
+
+	return {
+		transactionLogs: transactionLogs,
+		earliestTx: earliestTx,
+		mostRecentTx: mostRecentTx,
+	};
+}
+
+function chunk<T>(array: readonly T[], size: number): T[][] {
+	return new Array(Math.ceil(array.length / size))
+		.fill(null)
+		.map((_, index) => index * size)
+		.map((begin) => array.slice(begin, begin + size));
+}

package/src/events/pollingLogProvider.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingLogProvider = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+class PollingLogProvider {
+    constructor(connection, programId, commitment, frequency = 15 * 1000) {
+        this.connection = connection;
+        this.programId = programId;
+        this.frequency = frequency;
+        this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+    }
+    subscribe(callback) {
+        if (this.intervalId) {
+            return true;
+        }
+        this.intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.mutex === 1) {
+                return;
+            }
+            this.mutex = 1;
+            try {
+                const response = yield fetchLogs_1.fetchLogs(this.connection, this.programId, this.finality, undefined, this.mostRecentSeenTx);
+                if (response === undefined) {
+                    return;
+                }
+                const { mostRecentTx, transactionLogs } = response;
+                for (const { txSig, slot, logs } of transactionLogs) {
+                    callback(txSig, slot, logs);
+                }
+                this.mostRecentSeenTx = mostRecentTx;
+            }
+            catch (e) {
+                console.error('PollingLogProvider threw an Error');
+                console.error(e);
+            }
+            finally {
+                this.mutex = 0;
+            }
+        }), this.frequency);
+        return true;
+    }
+    isSubscribed() {
+        return this.intervalId !== undefined;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.intervalId !== undefined) {
+                clearInterval(this.intervalId);
+                this.intervalId = undefined;
+            }
+            return true;
+        });
+    }
+}
+exports.PollingLogProvider = PollingLogProvider;

package/src/events/pollingLogProvider.ts

@@ -0,0 +1,79 @@
+import { LogProvider, logProviderCallback } from './types';
+import {
+	Commitment,
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionSignature,
+} from '@solana/web3.js';
+import { fetchLogs } from './fetchLogs';
+
+export class PollingLogProvider implements LogProvider {
+	private finality: Finality;
+	private intervalId: NodeJS.Timer;
+	private mostRecentSeenTx?: TransactionSignature;
+	private mutex: number;
+
+	public constructor(
+		private connection: Connection,
+		private programId: PublicKey,
+		commitment: Commitment,
+		private frequency = 15 * 1000
+	) {
+		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+	}
+
+	public subscribe(callback: logProviderCallback): boolean {
+		if (this.intervalId) {
+			return true;
+		}
+
+		this.intervalId = setInterval(async () => {
+			if (this.mutex === 1) {
+				return;
+			}
+			this.mutex = 1;
+
+			try {
+				const response = await fetchLogs(
+					this.connection,
+					this.programId,
+					this.finality,
+					undefined,
+					this.mostRecentSeenTx
+				);
+
+				if (response === undefined) {
+					return;
+				}
+
+				const { mostRecentTx, transactionLogs } = response;
+
+				for (const { txSig, slot, logs } of transactionLogs) {
+					callback(txSig, slot, logs);
+				}
+
+				this.mostRecentSeenTx = mostRecentTx;
+			} catch (e) {
+				console.error('PollingLogProvider threw an Error');
+				console.error(e);
+			} finally {
+				this.mutex = 0;
+			}
+		}, this.frequency);
+
+		return true;
+	}
+
+	public isSubscribed(): boolean {
+		return this.intervalId !== undefined;
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		if (this.intervalId !== undefined) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+		return true;
+	}
+}

package/src/events/sort.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFn = void 0;
+const index_1 = require("../index");
+function clientSortAscFn() {
+    return 'less than';
+}
+function clientSortDescFn() {
+    return 'greater than';
+}
+function defaultBlockchainSortFn(currentEvent, newEvent) {
+    return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
+}
+function orderRecordSortFn(currentEvent, newEvent) {
+    const currentEventMarketIndex = !currentEvent.maker.equals(index_1.PublicKey.default)
+        ? currentEvent.makerOrder.marketIndex
+        : currentEvent.takerOrder.marketIndex;
+    const newEventMarketIndex = !newEvent.maker.equals(index_1.PublicKey.default)
+        ? newEvent.makerOrder.marketIndex
+        : newEvent.takerOrder.marketIndex;
+    if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+    }
+    if (currentEvent.fillRecordId.gt(index_1.ZERO) && newEvent.fillRecordId.gt(index_1.ZERO)) {
+        return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+            ? 'less than'
+            : 'greater than';
+    }
+    else {
+        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+    }
+}
+function getSortFn(orderBy, orderDir, eventType) {
+    if (orderBy === 'client') {
+        return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+    }
+    switch (eventType) {
+        case 'OrderRecord':
+            return orderRecordSortFn;
+        default:
+            return defaultBlockchainSortFn;
+    }
+}
+exports.getSortFn = getSortFn;