@drift-labs/sdk 2.48.0-beta.20 → 2.48.0-beta.22

package/VERSION

@@ -1 +1 @@
-2.48.0-beta.20
+2.48.0-beta.22

package/lib/events/eventSubscriber.js

@@ -27,7 +27,7 @@ class EventSubscriber {
         }
         this.eventEmitter = new events_1.EventEmitter();
         if (this.options.logProviderConfig.type === 'websocket') {
-            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.address, this.options.commitment, this.options.resubTimeoutMs);
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
         }
         else {
             this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
@@ -38,6 +38,27 @@ class EventSubscriber {
             if (this.logProvider.isSubscribed()) {
                 return true;
             }
+            if (this.options.logProviderConfig.type === 'websocket') {
+                if (this.options.logProviderConfig.resubTimeoutMs) {
+                    if (this.options.logProviderConfig.maxReconnectAttempts &&
+                        this.options.logProviderConfig.maxReconnectAttempts > 0) {
+                        const logProviderConfig = this.options
+                            .logProviderConfig;
+                        this.logProvider.eventEmitter.on('reconnect', (reconnectAttempts) => {
+                            if (reconnectAttempts > logProviderConfig.maxReconnectAttempts) {
+                                console.log('Failing over to polling');
+                                this.logProvider.eventEmitter.removeAllListeners('reconnect');
+                                this.unsubscribe().then(() => {
+                                    this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, this.options.commitment, logProviderConfig.fallbackFrequency, logProviderConfig.fallbackBatchSize);
+                                    this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
+                                        this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
+                                    }, true);
+                                });
+                            }
+                        });
+                    }
+                }
+            }
             this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
                 this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
             }, true);
@@ -95,7 +116,7 @@ class EventSubscriber {
         }
     }
     async unsubscribe() {
-        return await this.logProvider.unsubscribe();
+        return await this.logProvider.unsubscribe(true);
     }
     parseEventsFromLogs(txSig, slot, logs) {
         const records = [];

package/lib/events/pollingLogProvider.d.ts

@@ -11,7 +11,7 @@ export declare class PollingLogProvider implements LogProvider {
     private mutex;
     private firstFetch;
     constructor(connection: Connection, address: PublicKey, commitment: Commitment, frequency?: number, batchSize?: number);
-    subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): Promise<boolean>;
     isSubscribed(): boolean;
     unsubscribe(): Promise<boolean>;
 }

package/lib/events/pollingLogProvider.js

@@ -11,7 +11,7 @@ class PollingLogProvider {
         this.firstFetch = true;
         this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
     }
-    subscribe(callback, skipHistory) {
+    async subscribe(callback, skipHistory) {
         if (this.intervalId) {
             return true;
         }

package/lib/events/types.d.ts

@@ -1,5 +1,7 @@
+/// <reference types="node" />
 import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
 import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord, SwapRecord } from '../index';
+import { EventEmitter } from 'events';
 export type EventSubscriptionOptions = {
     address?: PublicKey;
     eventTypes?: EventType[];
@@ -10,7 +12,6 @@ export type EventSubscriptionOptions = {
     maxTx?: number;
     logProviderConfig?: LogProviderConfig;
     untilTx?: TransactionSignature;
-    resubTimeoutMs?: number;
 };
 export declare const DefaultEventSubscriptionOptions: EventSubscriptionOptions;
 export type EventSubscriptionOrderBy = 'blockchain' | 'client';
@@ -49,11 +50,16 @@ export type SortFn = (currentRecord: EventMap[EventType], newRecord: EventMap[Ev
 export type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined) => void;
 export interface LogProvider {
     isSubscribed(): boolean;
-    subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
-    unsubscribe(): Promise<boolean>;
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): Promise<boolean>;
+    unsubscribe(external?: boolean): Promise<boolean>;
+    eventEmitter?: EventEmitter;
 }
 export type WebSocketLogProviderConfig = {
     type: 'websocket';
+    resubTimeoutMs?: number;
+    maxReconnectAttempts?: number;
+    fallbackFrequency?: number;
+    fallbackBatchSize?: number;
 };
 export type PollingLogProviderConfig = {
     type: 'polling';

package/lib/events/webSocketLogProvider.d.ts

@@ -1,5 +1,7 @@
+/// <reference types="node" />
 import { LogProvider, logProviderCallback } from './types';
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
 export declare class WebSocketLogProvider implements LogProvider {
     private connection;
     private address;
@@ -7,12 +9,16 @@ export declare class WebSocketLogProvider implements LogProvider {
     private resubTimeoutMs?;
     private subscriptionId;
     private isUnsubscribing;
+    private externalUnsubscribe;
     private receivingData;
     private timeoutId?;
+    private reconnectAttempts;
+    eventEmitter?: EventEmitter;
     private callback?;
     constructor(connection: Connection, address: PublicKey, commitment: Commitment, resubTimeoutMs?: number);
-    subscribe(callback: logProviderCallback): boolean;
+    subscribe(callback: logProviderCallback): Promise<boolean>;
+    setSubscription(callback: logProviderCallback): void;
     isSubscribed(): boolean;
-    unsubscribe(): Promise<boolean>;
+    unsubscribe(external?: boolean): Promise<boolean>;
     private setTimeout;
 }

package/lib/events/webSocketLogProvider.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketLogProvider = void 0;
+const events_1 = require("events");
 class WebSocketLogProvider {
     constructor(connection, address, commitment, resubTimeoutMs) {
         this.connection = connection;
@@ -8,13 +9,31 @@ class WebSocketLogProvider {
         this.commitment = commitment;
         this.resubTimeoutMs = resubTimeoutMs;
         this.isUnsubscribing = false;
+        this.externalUnsubscribe = false;
         this.receivingData = false;
+        this.reconnectAttempts = 0;
+        if (this.resubTimeoutMs) {
+            this.eventEmitter = new events_1.EventEmitter();
+        }
     }
-    subscribe(callback) {
+    async subscribe(callback) {
         if (this.subscriptionId) {
             return true;
         }
         this.callback = callback;
+        try {
+            this.setSubscription(callback);
+        }
+        catch (error) {
+            // Sometimes ws connection isn't ready, give it a few secs
+            setTimeout(() => this.setSubscription(callback), 2000);
+        }
+        if (this.resubTimeoutMs) {
+            this.setTimeout();
+        }
+        return true;
+    }
+    setSubscription(callback) {
         this.subscriptionId = this.connection.onLogs(this.address, (logs, ctx) => {
             if (this.resubTimeoutMs && !this.isUnsubscribing) {
                 this.receivingData = true;
@@ -23,30 +42,27 @@ class WebSocketLogProvider {
             }
             callback(logs.signature, ctx.slot, logs.logs, undefined);
         }, this.commitment);
-        if (this.resubTimeoutMs) {
-            this.setTimeout();
-        }
-        return true;
     }
     isSubscribed() {
         return this.subscriptionId !== undefined;
     }
-    async unsubscribe() {
+    async unsubscribe(external = false) {
         this.isUnsubscribing = true;
+        this.externalUnsubscribe = external;
         clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
         if (this.subscriptionId !== undefined) {
-            this.connection
-                .removeOnLogsListener(this.subscriptionId)
-                .then(() => {
+            try {
+                await this.connection.removeOnLogsListener(this.subscriptionId);
                 this.subscriptionId = undefined;
                 this.isUnsubscribing = false;
                 return true;
-            })
-                .catch((err) => {
+            }
+            catch (err) {
                 console.log('Error unsubscribing from logs: ', err);
                 this.isUnsubscribing = false;
                 return false;
-            });
+            }
         }
         else {
             this.isUnsubscribing = false;
@@ -55,14 +71,16 @@ class WebSocketLogProvider {
     }
     setTimeout() {
         this.timeoutId = setTimeout(async () => {
-            if (this.isUnsubscribing) {
+            if (this.isUnsubscribing || this.externalUnsubscribe) {
                 // If we are in the process of unsubscribing, do not attempt to resubscribe
                 return;
             }
             if (this.receivingData) {
-                console.log(`No log data in ${this.resubTimeoutMs}ms, resubscribing`);
+                console.log(`No log data in ${this.resubTimeoutMs}ms, resubscribing on attempt ${this.reconnectAttempts + 1}`);
                 await this.unsubscribe();
                 this.receivingData = false;
+                this.reconnectAttempts++;
+                this.eventEmitter.emit('reconnect', this.reconnectAttempts);
                 this.subscribe(this.callback);
             }
         }, this.resubTimeoutMs);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.48.0-beta.20",
+	"version": "2.48.0-beta.22",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/events/eventSubscriber.ts

@@ -8,6 +8,7 @@ import {
 	EventMap,
 	LogProvider,
 	EventSubscriberEvents,
+	WebSocketLogProviderConfig,
 } from './types';
 import { TxEventCache } from './txEventCache';
 import { EventList } from './eventList';
@@ -57,7 +58,7 @@ export class EventSubscriber {
 				this.connection,
 				this.address,
 				this.options.commitment,
-				this.options.resubTimeoutMs
+				this.options.logProviderConfig.resubTimeoutMs
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(
@@ -76,6 +77,48 @@ export class EventSubscriber {
 				return true;
 			}
 
+			if (this.options.logProviderConfig.type === 'websocket') {
+				if (this.options.logProviderConfig.resubTimeoutMs) {
+					if (
+						this.options.logProviderConfig.maxReconnectAttempts &&
+						this.options.logProviderConfig.maxReconnectAttempts > 0
+					) {
+						const logProviderConfig = this.options
+							.logProviderConfig as WebSocketLogProviderConfig;
+						this.logProvider.eventEmitter.on(
+							'reconnect',
+							(reconnectAttempts) => {
+								if (
+									reconnectAttempts > logProviderConfig.maxReconnectAttempts
+								) {
+									console.log('Failing over to polling');
+									this.logProvider.eventEmitter.removeAllListeners('reconnect');
+									this.unsubscribe().then(() => {
+										this.logProvider = new PollingLogProvider(
+											this.connection,
+											this.address,
+											this.options.commitment,
+											logProviderConfig.fallbackFrequency,
+											logProviderConfig.fallbackBatchSize
+										);
+										this.logProvider.subscribe(
+											(txSig, slot, logs, mostRecentBlockTime) => {
+												this.handleTxLogs(
+													txSig,
+													slot,
+													logs,
+													mostRecentBlockTime
+												);
+											},
+											true
+										);
+									});
+								}
+							}
+						);
+					}
+				}
+			}
 			this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
 				this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
 			}, true);
@@ -159,7 +202,7 @@ export class EventSubscriber {
 	}
 
 	public async unsubscribe(): Promise<boolean> {
-		return await this.logProvider.unsubscribe();
+		return await this.logProvider.unsubscribe(true);
 	}
 
 	private parseEventsFromLogs(

package/src/events/pollingLogProvider.ts

@@ -25,10 +25,10 @@ export class PollingLogProvider implements LogProvider {
 		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
 	}
 
-	public subscribe(
+	public async subscribe(
 		callback: logProviderCallback,
 		skipHistory?: boolean
-	): boolean {
+	): Promise<boolean> {
 		if (this.intervalId) {
 			return true;
 		}

package/src/events/types.ts

@@ -15,6 +15,7 @@ import {
 	CurveRecord,
 	SwapRecord,
 } from '../index';
+import { EventEmitter } from 'events';
 
 export type EventSubscriptionOptions = {
 	address?: PublicKey;
@@ -28,7 +29,6 @@ export type EventSubscriptionOptions = {
 	// when the subscription starts, client might want to backtrack and fetch old tx's
 	// this specifies how far to backtrack
 	untilTx?: TransactionSignature;
-	resubTimeoutMs?: number;
 };
 
 export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
@@ -127,12 +127,20 @@ export type logProviderCallback = (
 
 export interface LogProvider {
 	isSubscribed(): boolean;
-	subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
-	unsubscribe(): Promise<boolean>;
+	subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): Promise<boolean>;
+	unsubscribe(external?: boolean): Promise<boolean>;
+	eventEmitter?: EventEmitter;
 }
 
 export type WebSocketLogProviderConfig = {
 	type: 'websocket';
+	resubTimeoutMs?: number;
+	maxReconnectAttempts?: number;
+	fallbackFrequency?: number;
+	fallbackBatchSize?: number;
 };
 
 export type PollingLogProviderConfig = {

package/src/events/webSocketLogProvider.ts

@@ -1,25 +1,48 @@
 import { LogProvider, logProviderCallback } from './types';
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
 
 export class WebSocketLogProvider implements LogProvider {
 	private subscriptionId: number;
 	private isUnsubscribing = false;
+	private externalUnsubscribe = false;
 	private receivingData = false;
 	private timeoutId?: NodeJS.Timeout;
+	private reconnectAttempts = 0;
+	eventEmitter?: EventEmitter;
 	private callback?: logProviderCallback;
 	public constructor(
 		private connection: Connection,
 		private address: PublicKey,
 		private commitment: Commitment,
 		private resubTimeoutMs?: number
-	) {}
+	) {
+		if (this.resubTimeoutMs) {
+			this.eventEmitter = new EventEmitter();
+		}
+	}
 
-	public subscribe(callback: logProviderCallback): boolean {
+	public async subscribe(callback: logProviderCallback): Promise<boolean> {
 		if (this.subscriptionId) {
 			return true;
 		}
 
 		this.callback = callback;
+		try {
+			this.setSubscription(callback);
+		} catch (error) {
+			// Sometimes ws connection isn't ready, give it a few secs
+			setTimeout(() => this.setSubscription(callback), 2000);
+		}
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+
+		return true;
+	}
+
+	public setSubscription(callback: logProviderCallback): void {
 		this.subscriptionId = this.connection.onLogs(
 			this.address,
 			(logs, ctx) => {
@@ -32,35 +55,29 @@ export class WebSocketLogProvider implements LogProvider {
 			},
 			this.commitment
 		);
-
-		if (this.resubTimeoutMs) {
-			this.setTimeout();
-		}
-
-		return true;
 	}
 
 	public isSubscribed(): boolean {
 		return this.subscriptionId !== undefined;
 	}
 
-	public async unsubscribe(): Promise<boolean> {
+	public async unsubscribe(external = false): Promise<boolean> {
 		this.isUnsubscribing = true;
+		this.externalUnsubscribe = external;
 		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
 
 		if (this.subscriptionId !== undefined) {
-			this.connection
-				.removeOnLogsListener(this.subscriptionId)
-				.then(() => {
-					this.subscriptionId = undefined;
-					this.isUnsubscribing = false;
-					return true;
-				})
-				.catch((err) => {
-					console.log('Error unsubscribing from logs: ', err);
-					this.isUnsubscribing = false;
-					return false;
-				});
+			try {
+				await this.connection.removeOnLogsListener(this.subscriptionId);
+				this.subscriptionId = undefined;
+				this.isUnsubscribing = false;
+				return true;
+			} catch (err) {
+				console.log('Error unsubscribing from logs: ', err);
+				this.isUnsubscribing = false;
+				return false;
+			}
 		} else {
 			this.isUnsubscribing = false;
 			return true;
@@ -69,15 +86,21 @@ export class WebSocketLogProvider implements LogProvider {
 
 	private setTimeout(): void {
 		this.timeoutId = setTimeout(async () => {
-			if (this.isUnsubscribing) {
+			if (this.isUnsubscribing || this.externalUnsubscribe) {
 				// If we are in the process of unsubscribing, do not attempt to resubscribe
 				return;
 			}
 
 			if (this.receivingData) {
-				console.log(`No log data in ${this.resubTimeoutMs}ms, resubscribing`);
+				console.log(
+					`No log data in ${this.resubTimeoutMs}ms, resubscribing on attempt ${
+						this.reconnectAttempts + 1
+					}`
+				);
 				await this.unsubscribe();
 				this.receivingData = false;
+				this.reconnectAttempts++;
+				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
 				this.subscribe(this.callback);
 			}
 		}, this.resubTimeoutMs);