@drift-labs/sdk 2.96.0-beta.0 → 2.96.0-beta.2

package/lib/driftClient.js

@@ -68,6 +68,7 @@ const utils_2 = require("./tx/utils");
 const pyth_solana_receiver_json_1 = __importDefault(require("./idl/pyth_solana_receiver.json"));
 const on_demand_1 = require("@switchboard-xyz/on-demand");
 const switchboard_on_demand_30_json_1 = __importDefault(require("./idl/switchboard_on_demand_30.json"));
+const grpcDriftClientAccountSubscriber_1 = require("./accounts/grpcDriftClientAccountSubscriber");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -80,7 +81,7 @@ class DriftClient {
         this._isSubscribed = val;
     }
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19;
         this.users = new Map();
         this._isSubscribed = false;
         this.perpMarketLastSlotCache = new Map();
@@ -143,18 +144,32 @@ class DriftClient {
                 accountLoader: config.accountSubscription.accountLoader,
             };
         }
+        else if (((_q = config.accountSubscription) === null || _q === void 0 ? void 0 : _q.type) === 'grpc') {
+            this.userAccountSubscriptionConfig = {
+                type: 'grpc',
+                resubTimeoutMs: (_r = config.accountSubscription) === null || _r === void 0 ? void 0 : _r.resubTimeoutMs,
+                logResubMessages: (_s = config.accountSubscription) === null || _s === void 0 ? void 0 : _s.logResubMessages,
+                configs: (_t = config.accountSubscription) === null || _t === void 0 ? void 0 : _t.configs,
+            };
+            this.userStatsAccountSubscriptionConfig = {
+                type: 'grpc',
+                resubTimeoutMs: (_u = config.accountSubscription) === null || _u === void 0 ? void 0 : _u.resubTimeoutMs,
+                logResubMessages: (_v = config.accountSubscription) === null || _v === void 0 ? void 0 : _v.logResubMessages,
+                configs: (_w = config.accountSubscription) === null || _w === void 0 ? void 0 : _w.configs,
+            };
+        }
         else {
             this.userAccountSubscriptionConfig = {
                 type: 'websocket',
-                resubTimeoutMs: (_q = config.accountSubscription) === null || _q === void 0 ? void 0 : _q.resubTimeoutMs,
-                logResubMessages: (_r = config.accountSubscription) === null || _r === void 0 ? void 0 : _r.logResubMessages,
-                commitment: (_s = config.accountSubscription) === null || _s === void 0 ? void 0 : _s.commitment,
+                resubTimeoutMs: (_x = config.accountSubscription) === null || _x === void 0 ? void 0 : _x.resubTimeoutMs,
+                logResubMessages: (_y = config.accountSubscription) === null || _y === void 0 ? void 0 : _y.logResubMessages,
+                commitment: (_z = config.accountSubscription) === null || _z === void 0 ? void 0 : _z.commitment,
             };
             this.userStatsAccountSubscriptionConfig = {
                 type: 'websocket',
-                resubTimeoutMs: (_t = config.accountSubscription) === null || _t === void 0 ? void 0 : _t.resubTimeoutMs,
-                logResubMessages: (_u = config.accountSubscription) === null || _u === void 0 ? void 0 : _u.logResubMessages,
-                commitment: (_v = config.accountSubscription) === null || _v === void 0 ? void 0 : _v.commitment,
+                resubTimeoutMs: (_0 = config.accountSubscription) === null || _0 === void 0 ? void 0 : _0.resubTimeoutMs,
+                logResubMessages: (_1 = config.accountSubscription) === null || _1 === void 0 ? void 0 : _1.logResubMessages,
+                commitment: (_2 = config.accountSubscription) === null || _2 === void 0 ? void 0 : _2.commitment,
             };
         }
         if (config.userStats) {
@@ -171,14 +186,20 @@ class DriftClient {
         const noMarketsAndOraclesSpecified = config.perpMarketIndexes === undefined &&
             config.spotMarketIndexes === undefined &&
             config.oracleInfos === undefined;
-        if (((_w = config.accountSubscription) === null || _w === void 0 ? void 0 : _w.type) === 'polling') {
-            this.accountSubscriber = new pollingDriftClientAccountSubscriber_1.PollingDriftClientAccountSubscriber(this.program, config.accountSubscription.accountLoader, (_x = config.perpMarketIndexes) !== null && _x !== void 0 ? _x : [], (_y = config.spotMarketIndexes) !== null && _y !== void 0 ? _y : [], (_z = config.oracleInfos) !== null && _z !== void 0 ? _z : [], noMarketsAndOraclesSpecified);
+        if (((_3 = config.accountSubscription) === null || _3 === void 0 ? void 0 : _3.type) === 'polling') {
+            this.accountSubscriber = new pollingDriftClientAccountSubscriber_1.PollingDriftClientAccountSubscriber(this.program, config.accountSubscription.accountLoader, (_4 = config.perpMarketIndexes) !== null && _4 !== void 0 ? _4 : [], (_5 = config.spotMarketIndexes) !== null && _5 !== void 0 ? _5 : [], (_6 = config.oracleInfos) !== null && _6 !== void 0 ? _6 : [], noMarketsAndOraclesSpecified);
+        }
+        else if (((_7 = config.accountSubscription) === null || _7 === void 0 ? void 0 : _7.type) === 'grpc') {
+            this.accountSubscriber = new grpcDriftClientAccountSubscriber_1.gprcDriftClientAccountSubscriber(config.accountSubscription.configs, this.program, (_8 = config.perpMarketIndexes) !== null && _8 !== void 0 ? _8 : [], (_9 = config.spotMarketIndexes) !== null && _9 !== void 0 ? _9 : [], (_10 = config.oracleInfos) !== null && _10 !== void 0 ? _10 : [], noMarketsAndOraclesSpecified, {
+                resubTimeoutMs: (_11 = config.accountSubscription) === null || _11 === void 0 ? void 0 : _11.resubTimeoutMs,
+                logResubMessages: (_12 = config.accountSubscription) === null || _12 === void 0 ? void 0 : _12.logResubMessages,
+            });
         }
         else {
-            this.accountSubscriber = new webSocketDriftClientAccountSubscriber_1.WebSocketDriftClientAccountSubscriber(this.program, (_0 = config.perpMarketIndexes) !== null && _0 !== void 0 ? _0 : [], (_1 = config.spotMarketIndexes) !== null && _1 !== void 0 ? _1 : [], (_2 = config.oracleInfos) !== null && _2 !== void 0 ? _2 : [], noMarketsAndOraclesSpecified, {
-                resubTimeoutMs: (_3 = config.accountSubscription) === null || _3 === void 0 ? void 0 : _3.resubTimeoutMs,
-                logResubMessages: (_4 = config.accountSubscription) === null || _4 === void 0 ? void 0 : _4.logResubMessages,
-            }, (_5 = config.accountSubscription) === null || _5 === void 0 ? void 0 : _5.commitment);
+            this.accountSubscriber = new webSocketDriftClientAccountSubscriber_1.WebSocketDriftClientAccountSubscriber(this.program, (_13 = config.perpMarketIndexes) !== null && _13 !== void 0 ? _13 : [], (_14 = config.spotMarketIndexes) !== null && _14 !== void 0 ? _14 : [], (_15 = config.oracleInfos) !== null && _15 !== void 0 ? _15 : [], noMarketsAndOraclesSpecified, {
+                resubTimeoutMs: (_16 = config.accountSubscription) === null || _16 === void 0 ? void 0 : _16.resubTimeoutMs,
+                logResubMessages: (_17 = config.accountSubscription) === null || _17 === void 0 ? void 0 : _17.logResubMessages,
+            }, (_18 = config.accountSubscription) === null || _18 === void 0 ? void 0 : _18.commitment);
         }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
         this.metricsEventEmitter = new events_1.EventEmitter();
@@ -186,7 +207,7 @@ class DriftClient {
             this.enableMetricsEvents = true;
         }
         this.txSender =
-            (_6 = config.txSender) !== null && _6 !== void 0 ? _6 : new retryTxSender_1.RetryTxSender({
+            (_19 = config.txSender) !== null && _19 !== void 0 ? _19 : new retryTxSender_1.RetryTxSender({
                 connection: this.connection,
                 wallet: this.wallet,
                 opts: this.opts,

package/lib/driftClientConfig.d.ts

@@ -5,6 +5,7 @@ import { BulkAccountLoader } from './accounts/bulkAccountLoader';
 import { DriftEnv } from './config';
 import { TxSender } from './tx/types';
 import { TxHandler, TxHandlerConfig } from './tx/txHandler';
+import { GrpcConfigs } from './accounts/types';
 export type DriftClientConfig = {
     connection: Connection;
     wallet: IWallet;
@@ -38,4 +39,9 @@ export type DriftClientSubscriptionConfig = {
 } | {
     type: 'polling';
     accountLoader: BulkAccountLoader;
+} | {
+    type: 'grpc';
+    configs: GrpcConfigs;
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
 };

package/lib/events/eventSubscriber.d.ts

@@ -15,12 +15,19 @@ export declare class EventSubscriber {
     private awaitTxPromises;
     private awaitTxResolver;
     private logProvider;
+    private currentProviderType;
     eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
     private lastSeenSlot;
     private lastSeenBlockTime;
     lastSeenTxSig: string;
     constructor(connection: Connection, program: Program, options?: EventSubscriptionOptions);
+    private initializeLogProvider;
     private populateInitialEventListMap;
+    /**
+     * Implements fallback logic for reconnecting to LogProvider. Currently terminates at polling,
+     * could be improved to try the original type again after some cooldown.
+     */
+    private updateFallbackProviderType;
     subscribe(): Promise<boolean>;
     private handleTxLogs;
     fetchPreviousTx(fetchMax?: boolean): Promise<void>;

package/lib/events/eventSubscriber.js

@@ -10,6 +10,7 @@ const webSocketLogProvider_1 = require("./webSocketLogProvider");
 const events_1 = require("events");
 const sort_1 = require("./sort");
 const parse_1 = require("./parse");
+const eventsServerLogProvider_1 = require("./eventsServerLogProvider");
 class EventSubscriber {
     constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
         var _a;
@@ -23,15 +24,36 @@ class EventSubscriber {
         this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
         this.eventListMap = new Map();
         this.eventEmitter = new events_1.EventEmitter();
-        if (this.options.logProviderConfig.type === 'websocket') {
+        this.currentProviderType = this.options.logProviderConfig.type;
+        this.initializeLogProvider();
+    }
+    initializeLogProvider(subscribe = false) {
+        if (this.currentProviderType === 'websocket') {
+            const logProviderConfig = this.options
+                .logProviderConfig;
             this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
             // @ts-ignore
-            this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
+            this.connection, this.address, this.options.commitment, logProviderConfig.resubTimeoutMs);
         }
-        else {
+        else if (this.currentProviderType === 'polling') {
+            const logProviderConfig = this.options
+                .logProviderConfig;
             this.logProvider = new pollingLogProvider_1.PollingLogProvider(
             // @ts-ignore
-            this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
+            this.connection, this.address, this.options.commitment, logProviderConfig.frequency, logProviderConfig.batchSize);
+        }
+        else if (this.currentProviderType === 'events-server') {
+            const logProviderConfig = this.options
+                .logProviderConfig;
+            this.logProvider = new eventsServerLogProvider_1.EventsServerLogProvider(logProviderConfig.url, this.options.eventTypes, this.options.address ? this.options.address.toString() : undefined);
+        }
+        else {
+            throw new Error(`Invalid log provider type: ${this.currentProviderType}`);
+        }
+        if (subscribe) {
+            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime, txSigIndex) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime, this.currentProviderType === 'events-server', txSigIndex);
+            }, true);
         }
     }
     populateInitialEventListMap() {
@@ -39,37 +61,51 @@ class EventSubscriber {
             this.eventListMap.set(eventType, new eventList_1.EventList(eventType, this.options.maxEventsPerType, (0, sort_1.getSortFn)(this.options.orderBy, this.options.orderDir), this.options.orderDir));
         }
     }
+    /**
+     * Implements fallback logic for reconnecting to LogProvider. Currently terminates at polling,
+     * could be improved to try the original type again after some cooldown.
+     */
+    updateFallbackProviderType(reconnectAttempts, maxReconnectAttempts) {
+        if (reconnectAttempts < maxReconnectAttempts) {
+            return;
+        }
+        let nextProviderType = this.currentProviderType;
+        if (this.currentProviderType === 'events-server') {
+            nextProviderType = 'websocket';
+        }
+        else if (this.currentProviderType === 'websocket') {
+            nextProviderType = 'polling';
+        }
+        else if (this.currentProviderType === 'polling') {
+            nextProviderType = 'polling';
+        }
+        console.log(`EventSubscriber: Failing over providerType ${this.currentProviderType} to ${nextProviderType}`);
+        this.currentProviderType = nextProviderType;
+    }
     async subscribe() {
         try {
             if (this.logProvider.isSubscribed()) {
                 return true;
             }
             this.populateInitialEventListMap();
-            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(
-                                    // @ts-ignore
-                                    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);
-                                });
-                            }
-                        });
-                    }
+            if (this.options.logProviderConfig.type === 'websocket' ||
+                this.options.logProviderConfig.type === 'events-server') {
+                const logProviderConfig = this.options
+                    .logProviderConfig;
+                if (this.logProvider.eventEmitter) {
+                    this.logProvider.eventEmitter.on('reconnect', async (reconnectAttempts) => {
+                        if (reconnectAttempts > logProviderConfig.maxReconnectAttempts) {
+                            console.log(`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${logProviderConfig.maxReconnectAttempts}, reconnecting...`);
+                            this.logProvider.eventEmitter.removeAllListeners('reconnect');
+                            await this.unsubscribe();
+                            this.updateFallbackProviderType(reconnectAttempts, logProviderConfig.maxReconnectAttempts);
+                            this.initializeLogProvider(true);
+                        }
+                    });
                 }
             }
-            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
-                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
+            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime, txSigIndex) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime, this.currentProviderType === 'events-server', txSigIndex);
             }, true);
             return true;
         }
@@ -79,11 +115,11 @@ class EventSubscriber {
             return false;
         }
     }
-    handleTxLogs(txSig, slot, logs, mostRecentBlockTime) {
-        if (this.txEventCache.has(txSig)) {
+    handleTxLogs(txSig, slot, logs, mostRecentBlockTime, fromEventsServer = false, txSigIndex = undefined) {
+        if (!fromEventsServer && this.txEventCache.has(txSig)) {
             return;
         }
-        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs, txSigIndex);
         for (const wrappedEvent of wrappedEvents) {
             this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
         }
@@ -134,7 +170,7 @@ class EventSubscriber {
         this.awaitTxResolver.clear();
         return await this.logProvider.unsubscribe(true);
     }
-    parseEventsFromLogs(txSig, slot, logs) {
+    parseEventsFromLogs(txSig, slot, logs, txSigIndex) {
         const records = [];
         // @ts-ignore
         const events = (0, parse_1.parseLogs)(this.program, logs);
@@ -146,7 +182,8 @@ class EventSubscriber {
                 event.data.txSig = txSig;
                 event.data.slot = slot;
                 event.data.eventType = event.name;
-                event.data.txSigIndex = runningEventIndex;
+                event.data.txSigIndex =
+                    txSigIndex !== undefined ? txSigIndex : runningEventIndex;
                 records.push(event.data);
             }
             runningEventIndex++;

package/lib/events/eventsServerLogProvider.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { logProviderCallback, EventType, LogProvider } from './types';
+import { EventEmitter } from 'events';
+export declare class EventsServerLogProvider implements LogProvider {
+    private readonly url;
+    private readonly eventTypes;
+    private readonly userAccount?;
+    private ws?;
+    private callback?;
+    private isUnsubscribing;
+    private externalUnsubscribe;
+    private lastHeartbeat;
+    private timeoutId?;
+    private reconnectAttempts;
+    eventEmitter?: EventEmitter;
+    constructor(url: string, eventTypes: EventType[], userAccount?: string);
+    isSubscribed(): boolean;
+    subscribe(callback: logProviderCallback): Promise<boolean>;
+    unsubscribe(external?: boolean): Promise<boolean>;
+    private setTimeout;
+}

package/lib/events/eventsServerLogProvider.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsServerLogProvider = void 0;
+const events_1 = require("events");
+// browser support
+let WebSocketImpl;
+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;
+class EventsServerLogProvider {
+    constructor(url, eventTypes, userAccount) {
+        this.url = url;
+        this.eventTypes = eventTypes;
+        this.userAccount = userAccount;
+        this.isUnsubscribing = false;
+        this.externalUnsubscribe = false;
+        this.lastHeartbeat = 0;
+        this.reconnectAttempts = 0;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    isSubscribed() {
+        return this.ws !== undefined;
+    }
+    async subscribe(callback) {
+        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;
+    }
+    async unsubscribe(external = false) {
+        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;
+        }
+    }
+    setTimeout() {
+        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);
+    }
+}
+exports.EventsServerLogProvider = EventsServerLogProvider;

package/lib/events/pollingLogProvider.js

@@ -30,7 +30,7 @@ class PollingLogProvider {
                 this.firstFetch = false;
                 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/lib/events/types.d.ts

@@ -48,23 +48,30 @@ export interface EventSubscriberEvents {
     newEvent: (event: WrappedEvent<EventType>) => void;
 }
 export type SortFn = (currentRecord: EventMap[EventType], newRecord: EventMap[EventType]) => 'less than' | 'greater than';
-export type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined) => void;
+export type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined, txSigIndex: number | undefined) => void;
 export interface LogProvider {
     isSubscribed(): boolean;
     subscribe(callback: logProviderCallback, skipHistory?: boolean): Promise<boolean>;
     unsubscribe(external?: boolean): Promise<boolean>;
     eventEmitter?: EventEmitter;
 }
-export type WebSocketLogProviderConfig = {
-    type: 'websocket';
-    resubTimeoutMs?: number;
+export type LogProviderType = 'websocket' | 'polling' | 'events-server';
+export type StreamingLogProviderConfig = {
     maxReconnectAttempts?: number;
     fallbackFrequency?: number;
     fallbackBatchSize?: number;
 };
+export type WebSocketLogProviderConfig = StreamingLogProviderConfig & {
+    type: 'websocket';
+    resubTimeoutMs?: number;
+};
 export type PollingLogProviderConfig = {
     type: 'polling';
     frequency: number;
     batchSize?: number;
 };
-export type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig;
+export type EventsServerLogProviderConfig = StreamingLogProviderConfig & {
+    type: 'events-server';
+    url: string;
+};
+export type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig | EventsServerLogProviderConfig;

package/lib/events/types.js

@@ -25,6 +25,10 @@ exports.DefaultEventSubscriptionOptions = {
     commitment: 'confirmed',
     maxTx: 4096,
     logProviderConfig: {
-        type: 'websocket',
+        type: 'events-server',
+        url: 'wss://events.drift.trade/ws',
+        maxReconnectAttempts: 5,
+        fallbackFrequency: 1000,
+        fallbackBatchSize: 100,
     },
 };

package/lib/events/webSocketLogProvider.js

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

package/lib/orderSubscriber/OrderSubscriber.d.ts

@@ -10,13 +10,14 @@ import { PollingSubscription } from './PollingSubscription';
 import { WebsocketSubscription } from './WebsocketSubscription';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
+import { grpcSubscription } from './grpcSubscription';
 export declare class OrderSubscriber {
     driftClient: DriftClient;
     usersAccounts: Map<string, {
         slot: number;
         userAccount: UserAccount;
     }>;
-    subscription: PollingSubscription | WebsocketSubscription;
+    subscription: PollingSubscription | WebsocketSubscription | grpcSubscription;
     commitment: Commitment;
     eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
     fetchPromise?: Promise<void>;

package/lib/orderSubscriber/OrderSubscriber.js

@@ -10,9 +10,10 @@ const WebsocketSubscription_1 = require("./WebsocketSubscription");
 const events_1 = require("events");
 const index_1 = require("../index");
 const user_1 = require("../decode/user");
+const grpcSubscription_1 = require("./grpcSubscription");
 class OrderSubscriber {
     constructor(config) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         this.usersAccounts = new Map();
         this.driftClient = config.driftClient;
         this.commitment = config.subscriptionConfig.commitment || 'processed';
@@ -22,8 +23,9 @@ class OrderSubscriber {
                 frequency: config.subscriptionConfig.frequency,
             });
         }
-        else {
-            this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
+        else if (config.subscriptionConfig.type === 'grpc') {
+            this.subscription = new grpcSubscription_1.grpcSubscription({
+                grpcConfigs: config.subscriptionConfig.configs,
                 orderSubscriber: this,
                 commitment: this.commitment,
                 skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
@@ -35,7 +37,20 @@ class OrderSubscriber {
                 decoded: config.decodeData,
             });
         }
-        if ((_c = config.fastDecode) !== null && _c !== void 0 ? _c : true) {
+        else {
+            this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
+                orderSubscriber: this,
+                commitment: this.commitment,
+                skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+                resubOpts: {
+                    resubTimeoutMs: (_c = config.subscriptionConfig) === null || _c === void 0 ? void 0 : _c.resubTimeoutMs,
+                    logResubMessages: (_d = config.subscriptionConfig) === null || _d === void 0 ? void 0 : _d.logResubMessages,
+                },
+                resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
+                decoded: config.decodeData,
+            });
+        }
+        if ((_e = config.fastDecode) !== null && _e !== void 0 ? _e : true) {
             this.decodeFn = (name, data) => (0, user_1.decodeUser)(data);
         }
         else {

package/lib/orderSubscriber/grpcSubscription.d.ts

@@ -0,0 +1,25 @@
+import { Commitment } from '@solana/web3.js';
+import { OrderSubscriber } from './OrderSubscriber';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+export declare class grpcSubscription {
+    private orderSubscriber;
+    private commitment;
+    private skipInitialLoad;
+    private resubOpts?;
+    private resyncIntervalMs?;
+    private subscriber?;
+    private resyncTimeoutId?;
+    private decoded?;
+    private grpcConfigs;
+    constructor({ grpcConfigs, orderSubscriber, commitment, skipInitialLoad, resubOpts, resyncIntervalMs, decoded, }: {
+        grpcConfigs: GrpcConfigs;
+        orderSubscriber: OrderSubscriber;
+        commitment: Commitment;
+        skipInitialLoad?: boolean;
+        resubOpts?: ResubOpts;
+        resyncIntervalMs?: number;
+        decoded?: boolean;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}