@drift-labs/sdk 2.96.0-beta.1 → 2.96.0-beta.3

package/src/events/eventsServerLogProvider.ts

@@ -0,0 +1,152 @@
+// import WebSocket from 'ws';
+import { logProviderCallback, EventType, LogProvider } from './types';
+import { EventEmitter } from 'events';
+
+// browser support
+let WebSocketImpl: typeof WebSocket;
+if (typeof window !== 'undefined' && window.WebSocket) {
+	WebSocketImpl = window.WebSocket;
+} else {
+	WebSocketImpl = require('ws');
+}
+
+const EVENT_SERVER_HEARTBEAT_INTERVAL_MS = 5000;
+const ALLOWED_MISSED_HEARTBEATS = 3;
+
+export class EventsServerLogProvider implements LogProvider {
+	private ws?: WebSocket;
+	private callback?: logProviderCallback;
+	private isUnsubscribing = false;
+	private externalUnsubscribe = false;
+	private lastHeartbeat = 0;
+	private timeoutId?: NodeJS.Timeout;
+	private reconnectAttempts = 0;
+	eventEmitter?: EventEmitter;
+
+	public constructor(
+		private readonly url: string,
+		private readonly eventTypes: EventType[],
+		private readonly userAccount?: string
+	) {
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public isSubscribed(): boolean {
+		return this.ws !== undefined;
+	}
+
+	public async subscribe(callback: logProviderCallback): Promise<boolean> {
+		if (this.ws !== undefined) {
+			return true;
+		}
+		this.ws = new WebSocketImpl(this.url);
+
+		this.callback = callback;
+		this.ws.addEventListener('open', () => {
+			for (const channel of this.eventTypes) {
+				const subscribeMessage = {
+					type: 'subscribe',
+					channel: channel,
+				};
+				if (this.userAccount) {
+					subscribeMessage['user'] = this.userAccount;
+				}
+				this.ws.send(JSON.stringify(subscribeMessage));
+			}
+			this.reconnectAttempts = 0;
+		});
+
+		this.ws.addEventListener('message', (data) => {
+			try {
+				if (!this.isUnsubscribing) {
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+					if (this.reconnectAttempts > 0) {
+						console.log(
+							'eventsServerLogProvider: Resetting reconnect attempts to 0'
+						);
+					}
+					this.reconnectAttempts = 0;
+				}
+
+				const parsedData = JSON.parse(data.data.toString());
+				if (parsedData.channel === 'heartbeat') {
+					this.lastHeartbeat = Date.now();
+					return;
+				}
+				if (parsedData.message !== undefined) {
+					return;
+				}
+				const event = JSON.parse(parsedData.data);
+				this.callback(
+					event.txSig,
+					event.slot,
+					[
+						'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH invoke [1]',
+						event.rawLog,
+						'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH success',
+					],
+					undefined,
+					event.txSigIndex
+				);
+			} catch (error) {
+				console.error('Error parsing message:', error);
+			}
+		});
+
+		this.ws.addEventListener('close', () => {
+			console.log('eventsServerLogProvider: WebSocket closed');
+		});
+
+		this.ws.addEventListener('error', (error) => {
+			console.error('eventsServerLogProvider: WebSocket error:', error);
+		});
+
+		this.setTimeout();
+
+		return true;
+	}
+
+	public async unsubscribe(external = false): Promise<boolean> {
+		this.isUnsubscribing = true;
+		this.externalUnsubscribe = external;
+		if (this.timeoutId) {
+			clearInterval(this.timeoutId);
+			this.timeoutId = undefined;
+		}
+
+		if (this.ws !== undefined) {
+			this.ws.close();
+			this.ws = undefined;
+			return true;
+		} else {
+			this.isUnsubscribing = false;
+			return true;
+		}
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing || this.externalUnsubscribe) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeat;
+			if (
+				timeSinceLastHeartbeat >
+				EVENT_SERVER_HEARTBEAT_INTERVAL_MS * ALLOWED_MISSED_HEARTBEATS
+			) {
+				console.log(
+					`eventServerLogProvider: No heartbeat in ${timeSinceLastHeartbeat}ms, resubscribing on attempt ${
+						this.reconnectAttempts + 1
+					}`
+				);
+				await this.unsubscribe();
+				this.reconnectAttempts++;
+				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
+				this.subscribe(this.callback);
+			}
+		}, EVENT_SERVER_HEARTBEAT_INTERVAL_MS * 2);
+	}
+}

package/src/events/pollingLogProvider.ts

@@ -60,7 +60,7 @@ export class PollingLogProvider implements LogProvider {
 				const { mostRecentTx, transactionLogs } = response;
 
 				for (const { txSig, slot, logs } of transactionLogs) {
-					callback(txSig, slot, logs, response.mostRecentBlockTime);
+					callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
 				}
 
 				this.mostRecentSeenTx = mostRecentTx;

package/src/events/types.ts

@@ -56,7 +56,11 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 	commitment: 'confirmed',
 	maxTx: 4096,
 	logProviderConfig: {
-		type: 'websocket',
+		type: 'events-server',
+		url: 'wss://events.drift.trade/ws',
+		maxReconnectAttempts: 5,
+		fallbackFrequency: 1000,
+		fallbackBatchSize: 100,
 	},
 };
 
@@ -126,7 +130,8 @@ export type logProviderCallback = (
 	txSig: TransactionSignature,
 	slot: number,
 	logs: string[],
-	mostRecentBlockTime: number | undefined
+	mostRecentBlockTime: number | undefined,
+	txSigIndex: number | undefined
 ) => void;
 
 export interface LogProvider {
@@ -139,20 +144,38 @@ export interface LogProvider {
 	eventEmitter?: EventEmitter;
 }
 
-export type WebSocketLogProviderConfig = {
-	type: 'websocket';
-	resubTimeoutMs?: number;
+export type LogProviderType = 'websocket' | 'polling' | 'events-server';
+
+export type StreamingLogProviderConfig = {
+	/// Max number of times to try reconnecting before failing over to fallback provider
 	maxReconnectAttempts?: number;
+	/// used for PollingLogProviderConfig on fallback
 	fallbackFrequency?: number;
+	/// used for PollingLogProviderConfig on fallback
 	fallbackBatchSize?: number;
 };
 
+export type WebSocketLogProviderConfig = StreamingLogProviderConfig & {
+	type: 'websocket';
+	/// Max time to wait before resubscribing
+	resubTimeoutMs?: number;
+};
+
 export type PollingLogProviderConfig = {
 	type: 'polling';
+	/// frequency to poll for new events
 	frequency: number;
+	/// max number of events to fetch per poll
 	batchSize?: number;
 };
 
+export type EventsServerLogProviderConfig = StreamingLogProviderConfig & {
+	type: 'events-server';
+	/// url of the events server
+	url: string;
+};
+
 export type LogProviderConfig =
 	| WebSocketLogProviderConfig
-	| PollingLogProviderConfig;
+	| PollingLogProviderConfig
+	| EventsServerLogProviderConfig;

package/src/events/webSocketLogProvider.ts

@@ -64,7 +64,7 @@ export class WebSocketLogProvider implements LogProvider {
 				if (logs.err !== null) {
 					return;
 				}
-				callback(logs.signature, ctx.slot, logs.logs, undefined);
+				callback(logs.signature, ctx.slot, logs.logs, undefined, undefined);
 			},
 			this.commitment
 		);
@@ -106,9 +106,9 @@ export class WebSocketLogProvider implements LogProvider {
 
 			if (this.receivingData) {
 				console.log(
-					`No log data in ${this.resubTimeoutMs}ms, resubscribing on attempt ${
-						this.reconnectAttempts + 1
-					}`
+					`webSocketLogProvider: No log data in ${
+						this.resubTimeoutMs
+					}ms, resubscribing on attempt ${this.reconnectAttempts + 1}`
 				);
 				await this.unsubscribe();
 				this.receivingData = false;

package/src/orderSubscriber/OrderSubscriber.ts

@@ -11,12 +11,11 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { BN } from '../index';
 import { decodeUser } from '../decode/user';
-import { grpcSubscription } from './grpcSubscription';
 
 export class OrderSubscriber {
 	driftClient: DriftClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
-	subscription: PollingSubscription | WebsocketSubscription | grpcSubscription;
+	subscription: PollingSubscription | WebsocketSubscription;
 	commitment: Commitment;
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
@@ -35,19 +34,6 @@ export class OrderSubscriber {
 				orderSubscriber: this,
 				frequency: config.subscriptionConfig.frequency,
 			});
-		} else if (config.subscriptionConfig.type === 'grpc') {
-			this.subscription = new grpcSubscription({
-				grpcConfigs: config.subscriptionConfig.configs,
-				orderSubscriber: this,
-				commitment: this.commitment,
-				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
-				resubOpts: {
-					resubTimeoutMs: config.subscriptionConfig?.resubTimeoutMs,
-					logResubMessages: config.subscriptionConfig?.logResubMessages,
-				},
-				resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
-				decoded: config.decodeData,
-			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,

package/src/orderSubscriber/types.ts

@@ -1,7 +1,6 @@
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { Order, UserAccount } from '../types';
 import { DriftClient } from '../driftClient';
-import { GrpcConfigs } from '../accounts/types';
 
 export type OrderSubscriberConfig = {
 	driftClient: DriftClient;
@@ -11,15 +10,6 @@ export type OrderSubscriberConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
-		| {
-				type: 'grpc';
-				skipInitialLoad?: boolean;
-				resubTimeoutMs?: number;
-				logResubMessages?: boolean;
-				resyncIntervalMs?: number;
-				configs: GrpcConfigs;
-				commitment?: Commitment;
-		  }
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;

package/src/user.ts

@@ -98,7 +98,6 @@ import {
 	calculatePerpFuelBonus,
 	calculateInsuranceFuelBonus,
 } from './math/fuel';
-import { grpcUserAccountSubscriber } from './accounts/grpcUserAccountSubscriber';
 
 export class User {
 	driftClient: DriftClient;
@@ -129,16 +128,6 @@ export class User {
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
-		} else if (config.accountSubscription?.type === 'grpc') {
-			this.accountSubscriber = new grpcUserAccountSubscriber(
-				config.accountSubscription.configs,
-				config.driftClient.program,
-				config.userAccountPublicKey,
-				{
-					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
-					logResubMessages: config.accountSubscription?.logResubMessages,
-				}
-			);
 		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,

package/src/userConfig.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-import { GrpcConfigs, UserAccountSubscriber } from './accounts/types';
+import { UserAccountSubscriber } from './accounts/types';
 
 export type UserConfig = {
 	accountSubscription?: UserSubscriptionConfig;
@@ -23,10 +23,4 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'custom';
 			userAccountSubscriber: UserAccountSubscriber;
-	  }
-	| {
-			type: 'grpc';
-			resubTimeoutMs?: number;
-			logResubMessages?: boolean;
-			configs: GrpcConfigs;
 	  };

package/src/userMap/userMap.ts

@@ -36,7 +36,6 @@ import {
 import { WebsocketSubscription } from './WebsocketSubscription';
 import { PollingSubscription } from './PollingSubscription';
 import { decodeUser } from '../decode/user';
-import { grpcSubscription } from './grpcSubscription';
 
 const MAX_USER_ACCOUNT_SIZE_BYTES = 4376;
 
@@ -76,10 +75,7 @@ export class UserMap implements UserMapInterface {
 	private includeIdle: boolean;
 	private disableSyncOnTotalAccountsChange: boolean;
 	private lastNumberOfSubAccounts: BN;
-	private subscription:
-		| PollingSubscription
-		| WebsocketSubscription
-		| grpcSubscription;
+	private subscription: PollingSubscription | WebsocketSubscription;
 	private stateAccountUpdateCallback = async (state: StateAccount) => {
 		if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
 			await this.sync();
@@ -126,18 +122,6 @@ export class UserMap implements UserMapInterface {
 				frequency: config.subscriptionConfig.frequency,
 				skipInitialLoad: config.skipInitialLoad,
 			});
-		} else if (config.subscriptionConfig.type === 'grpc') {
-			this.subscription = new grpcSubscription({
-				configs: config.subscriptionConfig.configs,
-				userMap: this,
-				commitment: this.commitment,
-				resubOpts: {
-					resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
-					logResubMessages: config.subscriptionConfig.logResubMessages,
-				},
-				skipInitialLoad: config.skipInitialLoad,
-				decodeFn,
-			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				userMap: this,

package/src/userMap/userMapConfig.ts

@@ -1,6 +1,5 @@
 import { Commitment, Connection } from '@solana/web3.js';
 import { DriftClient } from '../driftClient';
-import { GrpcConfigs } from '../accounts/types';
 
 // passed into UserMap.getUniqueAuthorities to filter users
 export type UserAccountFilterCriteria = {
@@ -28,13 +27,6 @@ export type UserMapConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
-		| {
-				type: 'grpc';
-				configs: GrpcConfigs;
-				resubTimeoutMs?: number;
-				logResubMessages?: boolean;
-				commitment?: Commitment;
-		  }
 		| {
 				type: 'websocket';
 				resubTimeoutMs?: number;

package/src/userStatsConfig.ts

@@ -1,7 +1,6 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-import { GrpcConfigs } from './accounts/types';
 
 export type UserStatsConfig = {
 	accountSubscription?: UserStatsSubscriptionConfig;
@@ -22,10 +21,4 @@ export type UserStatsSubscriptionConfig =
 	  }
 	| {
 			type: 'custom';
-	  }
-	| {
-			type: 'grpc';
-			resubTimeoutMs?: number;
-			logResubMessages?: boolean;
-			configs: GrpcConfigs;
 	  };

package/lib/accounts/grpcAccountSubscriber.d.ts

@@ -1,16 +0,0 @@
-/// <reference types="node" />
-import { ResubOpts, GrpcConfigs } from './types';
-import { Program } from '@coral-xyz/anchor';
-import { PublicKey } from '@solana/web3.js';
-import { ClientDuplexStream } from '@grpc/grpc-js';
-import Client, { CommitmentLevel, SubscribeRequest, SubscribeUpdate } from '@triton-one/yellowstone-grpc';
-import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-export declare class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber<T> {
-    client: Client;
-    stream: ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
-    commitmentLevel: CommitmentLevel;
-    listenerId?: number;
-    constructor(grpcConfigs: GrpcConfigs, accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T, resubOpts?: ResubOpts);
-    subscribe(onChange: (data: T) => void): Promise<void>;
-    unsubscribe(onResub?: boolean): Promise<void>;
-}

package/lib/accounts/grpcAccountSubscriber.js

@@ -1,155 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.grpcAccountSubscriber = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const Buffer = __importStar(require("buffer"));
-const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
-const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
-class grpcAccountSubscriber extends webSocketAccountSubscriber_1.WebSocketAccountSubscriber {
-    constructor(grpcConfigs, accountName, program, accountPublicKey, decodeBuffer, resubOpts) {
-        var _a, _b;
-        super(accountName, program, accountPublicKey, decodeBuffer, resubOpts);
-        this.client = new yellowstone_grpc_1.default(grpcConfigs.endpoint, grpcConfigs.token, (_a = grpcConfigs.channelOptions) !== null && _a !== void 0 ? _a : {});
-        this.commitmentLevel =
-            (_b = grpcConfigs.commitmentLevel) !== null && _b !== void 0 ? _b : yellowstone_grpc_1.CommitmentLevel.CONFIRMED;
-    }
-    async subscribe(onChange) {
-        if (this.listenerId != null || this.isUnsubscribing) {
-            return;
-        }
-        this.onChange = onChange;
-        if (!this.dataAndSlot) {
-            await this.fetch();
-        }
-        // Subscribe with grpc
-        this.stream = await this.client.subscribe();
-        const request = {
-            slots: {
-                slots: {},
-            },
-            accounts: {
-                account: {
-                    account: [this.accountPublicKey.toString()],
-                    owner: [],
-                    filters: [],
-                },
-            },
-            transactions: {},
-            blocks: {},
-            blocksMeta: {},
-            accountsDataSlice: [],
-            commitment: this.commitmentLevel,
-            entry: {},
-            transactionsStatus: {},
-        };
-        this.stream.on('data', (chunk) => {
-            var _a;
-            if (!chunk.account) {
-                return;
-            }
-            const slot = Number(chunk.account.slot);
-            const accountInfo = {
-                owner: new web3_js_1.PublicKey(chunk.account.account.owner),
-                lamports: Number(chunk.account.account.lamports),
-                data: Buffer.Buffer.from(chunk.account.account.data),
-                executable: chunk.account.account.executable,
-                rentEpoch: Number(chunk.account.account.rentEpoch),
-            };
-            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
-                this.receivingData = true;
-                clearTimeout(this.timeoutId);
-                this.handleRpcResponse({
-                    slot,
-                }, accountInfo);
-                this.setTimeout();
-            }
-            else {
-                this.handleRpcResponse({
-                    slot,
-                }, accountInfo);
-            }
-        });
-        return new Promise((resolve, reject) => {
-            this.stream.write(request, (err) => {
-                var _a;
-                if (err === null || err === undefined) {
-                    this.listenerId = 1;
-                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
-                        this.receivingData = true;
-                        this.setTimeout();
-                    }
-                    resolve();
-                }
-                else {
-                    reject(err);
-                }
-            });
-        }).catch((reason) => {
-            console.error(reason);
-            throw reason;
-        });
-    }
-    async unsubscribe(onResub = false) {
-        if (!onResub && this.resubOpts) {
-            this.resubOpts.resubTimeoutMs = undefined;
-        }
-        this.isUnsubscribing = true;
-        clearTimeout(this.timeoutId);
-        this.timeoutId = undefined;
-        if (this.listenerId != null) {
-            const promise = new Promise((resolve, reject) => {
-                const request = {
-                    slots: {},
-                    accounts: {},
-                    transactions: {},
-                    blocks: {},
-                    blocksMeta: {},
-                    accountsDataSlice: [],
-                    entry: {},
-                    transactionsStatus: {},
-                };
-                this.stream.write(request, (err) => {
-                    if (err === null || err === undefined) {
-                        this.listenerId = undefined;
-                        this.isUnsubscribing = false;
-                        resolve();
-                    }
-                    else {
-                        reject(err);
-                    }
-                });
-            }).catch((reason) => {
-                console.error(reason);
-                throw reason;
-            });
-            return promise;
-        }
-        else {
-            this.isUnsubscribing = false;
-        }
-    }
-}
-exports.grpcAccountSubscriber = grpcAccountSubscriber;

package/lib/accounts/grpcDriftClientAccountSubscriber.d.ts

@@ -1,13 +0,0 @@
-import { WebSocketDriftClientAccountSubscriber } from './webSocketDriftClientAccountSubscriber';
-import { OracleInfo } from '../oracles/types';
-import { Program } from '@coral-xyz/anchor';
-import { GrpcConfigs, ResubOpts } from './types';
-import { Commitment } from '@solana/web3.js';
-export declare class gprcDriftClientAccountSubscriber extends WebSocketDriftClientAccountSubscriber {
-    private grpcConfigs;
-    constructor(grpcConfigs: GrpcConfigs, program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, resubOpts?: ResubOpts, commitment?: Commitment);
-    subscribe(): Promise<boolean>;
-    subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean>;
-    subscribeToPerpMarketAccount(marketIndex: number): Promise<boolean>;
-    subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
-}