@velocity-exchange/sdk 0.0.1

package/lib/browser/events/parse.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLogsForCuUsage = exports.parseLogsWithRaw = exports.parseLogs = void 0;
+const driftProgramId = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
+const PROGRAM_LOG = 'Program log: ';
+const PROGRAM_INSTRUCTION = 'Program log: Instruction: ';
+const PROGRAM_DATA = 'Program data: ';
+const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
+const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
+const PROGRAM_INSTRUCTION_START_INDEX = PROGRAM_INSTRUCTION.length;
+function parseLogs(program, logs, programId = driftProgramId) {
+    const { events } = parseLogsWithRaw(program, logs, programId);
+    return events;
+}
+exports.parseLogs = parseLogs;
+function parseLogsWithRaw(program, logs, programId = driftProgramId) {
+    const events = [];
+    const rawLogs = [];
+    const execution = new ExecutionContext();
+    for (const log of logs) {
+        if (log.startsWith('Log truncated')) {
+            break;
+        }
+        const [event, newProgram, didPop] = handleLog(execution, log, program, programId);
+        if (event) {
+            events.push(event);
+            rawLogs.push(log);
+        }
+        if (newProgram) {
+            execution.push(newProgram);
+        }
+        if (didPop) {
+            execution.pop();
+        }
+    }
+    return { events, rawLogs };
+}
+exports.parseLogsWithRaw = parseLogsWithRaw;
+function handleLog(execution, log, program, programId = driftProgramId) {
+    // Executing program is drift program.
+    if (execution.stack.length > 0 && execution.program() === programId) {
+        return handleProgramLog(log, program, programId);
+    }
+    // Executing program is not drift program.
+    else {
+        return [null, ...handleSystemLog(log, programId)];
+    }
+}
+// Handles logs from *drift* program.
+function handleProgramLog(log, program, programId = driftProgramId) {
+    // This is a `msg!` log or a `sol_log_data` log.
+    if (log.startsWith(PROGRAM_LOG)) {
+        const logStr = log.slice(PROGRAM_LOG_START_INDEX);
+        const event = program.coder.events.decode(logStr);
+        return [event, null, false];
+    }
+    else if (log.startsWith(PROGRAM_DATA)) {
+        const logStr = log.slice(PROGRAM_DATA_START_INDEX);
+        const event = program.coder.events.decode(logStr);
+        return [event, null, false];
+    }
+    else {
+        return [null, ...handleSystemLog(log, programId)];
+    }
+}
+// Handles logs when the current program being executing is *not* drift.
+function handleSystemLog(log, programId = driftProgramId) {
+    // System component.
+    const logStart = log.split(':')[0];
+    const programStart = `Program ${programId} invoke`;
+    // Did the program finish executing?
+    if (logStart.match(/^Program (.*) success/g) !== null) {
+        return [null, true];
+        // Recursive call.
+    }
+    else if (logStart.startsWith(programStart)) {
+        return [programId, false];
+    }
+    // CPI call.
+    else if (logStart.includes('invoke')) {
+        return ['cpi', false]; // Any string will do.
+    }
+    else {
+        return [null, false];
+    }
+}
+// Stack frame execution context, allowing one to track what program is
+// executing for a given log.
+class ExecutionContext {
+    constructor() {
+        this.stack = [];
+        this.ixStack = [];
+    }
+    program() {
+        if (!this.stack.length) {
+            throw new Error('Expected the stack to have elements');
+        }
+        return this.stack[this.stack.length - 1];
+    }
+    push(newProgram) {
+        this.stack.push(newProgram);
+    }
+    pop() {
+        if (!this.stack.length) {
+            throw new Error('Expected the stack to have elements');
+        }
+        this.stack.pop();
+    }
+    ix() {
+        if (!this.ixStack.length) {
+            throw new Error('Expected the ix stack to have elements');
+        }
+        return this.ixStack[this.ixStack.length - 1];
+    }
+    pushIx(newIx) {
+        this.ixStack.push(newIx);
+    }
+    popIx() {
+        this.ixStack.pop();
+    }
+}
+function parseLogsForCuUsage(logs, programId = driftProgramId) {
+    const cuUsageEvents = [];
+    const execution = new ExecutionContext();
+    for (const log of logs) {
+        if (log.startsWith('Log truncated')) {
+            break;
+        }
+        const [newProgram, newIx, didPopProgram, didPopIx] = handleLogForCuUsage(execution, log, programId);
+        if (newProgram) {
+            execution.push(newProgram);
+        }
+        if (newIx) {
+            execution.pushIx(newIx);
+        }
+        if (didPopProgram) {
+            execution.pop();
+        }
+        if (didPopIx !== null) {
+            cuUsageEvents.push({
+                name: 'CuUsage',
+                data: {
+                    instruction: execution.ix(),
+                    cuUsage: didPopIx,
+                },
+            });
+            execution.popIx();
+        }
+    }
+    return cuUsageEvents;
+}
+exports.parseLogsForCuUsage = parseLogsForCuUsage;
+function handleLogForCuUsage(execution, log, programId = driftProgramId) {
+    if (execution.stack.length > 0 && execution.program() === programId) {
+        return handleProgramLogForCuUsage(log, programId);
+    }
+    else {
+        return handleSystemLogForCuUsage(log, programId);
+    }
+}
+function handleProgramLogForCuUsage(log, programId = driftProgramId) {
+    if (log.startsWith(PROGRAM_INSTRUCTION)) {
+        const ixStr = log.slice(PROGRAM_INSTRUCTION_START_INDEX);
+        return [null, ixStr, false, null];
+    }
+    else {
+        return handleSystemLogForCuUsage(log, programId);
+    }
+}
+function handleSystemLogForCuUsage(log, programId = driftProgramId) {
+    // System component.
+    const logStart = log.split(':')[0];
+    const programStart = `Program ${programId} invoke`;
+    // Did the program finish executing?
+    if (logStart.match(/^Program (.*) success/g) !== null) {
+        return [null, null, true, null];
+        // Recursive call.
+    }
+    else if (logStart.startsWith(programStart)) {
+        return [programId, null, false, null];
+        // Consumed CU log.
+    }
+    else if (log.startsWith(`Program ${programId} consumed `)) {
+        // Extract CU usage, e.g. 'Program ... consumed 29242 of 199700 compute units'
+        // We need to extract the consumed value (29242)
+        const matches = log.match(/consumed (\d+) of \d+ compute units/);
+        if (matches) {
+            return [null, null, false, Number(matches[1])];
+        }
+        return [null, null, false, null];
+    }
+    // CPI call.
+    else if (logStart.includes('invoke')) {
+        return ['cpi', null, false, null]; // Any string will do.
+    }
+    else {
+        return [null, null, false, null];
+    }
+}

package/lib/browser/events/pollingLogProvider.d.ts

@@ -0,0 +1,17 @@
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+export declare class PollingLogProvider implements LogProvider {
+    private connection;
+    private address;
+    private frequency;
+    private batchSize?;
+    private finality;
+    private intervalId;
+    private mostRecentSeenTx?;
+    private mutex;
+    private firstFetch;
+    constructor(connection: Connection, address: PublicKey, commitment: Commitment, frequency?: number, batchSize?: number);
+    subscribe(callback: logProviderCallback, skipHistory?: boolean): Promise<boolean>;
+    isSubscribed(): boolean;
+    unsubscribe(): Promise<boolean>;
+}

package/lib/browser/events/pollingLogProvider.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingLogProvider = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+class PollingLogProvider {
+    constructor(connection, address, commitment, frequency = 15 * 1000, batchSize) {
+        this.connection = connection;
+        this.address = address;
+        this.frequency = frequency;
+        this.batchSize = batchSize;
+        this.firstFetch = true;
+        this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+    }
+    async subscribe(callback, skipHistory) {
+        if (this.intervalId) {
+            return true;
+        }
+        this.intervalId = setInterval(async () => {
+            if (this.mutex === 1) {
+                return;
+            }
+            this.mutex = 1;
+            try {
+                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.address, this.finality, undefined, this.mostRecentSeenTx, 
+                // If skipping history, only fetch one log back, not the maximum amount available
+                skipHistory && this.firstFetch ? 1 : undefined, this.batchSize);
+                if (response === undefined) {
+                    return;
+                }
+                this.firstFetch = false;
+                const { mostRecentTx, transactionLogs } = response;
+                for (const { txSig, slot, logs } of transactionLogs) {
+                    callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
+                }
+                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;
+    }
+    async unsubscribe() {
+        if (this.intervalId !== undefined) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+        return true;
+    }
+}
+exports.PollingLogProvider = PollingLogProvider;

package/lib/browser/events/sort.d.ts

@@ -0,0 +1,2 @@
+import { EventSubscriptionOrderBy, EventSubscriptionOrderDirection, SortFn } from './types';
+export declare function getSortFn(orderBy: EventSubscriptionOrderBy, orderDir: EventSubscriptionOrderDirection): SortFn;

package/lib/browser/events/sort.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFn = void 0;
+function clientSortAscFn() {
+    return 'less than';
+}
+function clientSortDescFn() {
+    return 'greater than';
+}
+function blockchainSortFn(currentEvent, newEvent) {
+    if (currentEvent.slot == newEvent.slot) {
+        return currentEvent.txSigIndex < newEvent.txSigIndex
+            ? 'less than'
+            : 'greater than';
+    }
+    return currentEvent.slot < newEvent.slot ? 'less than' : 'greater than';
+}
+function getSortFn(orderBy, orderDir) {
+    if (orderBy === 'client') {
+        return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+    }
+    return blockchainSortFn;
+}
+exports.getSortFn = getSortFn;

package/lib/browser/events/txEventCache.d.ts

@@ -0,0 +1,24 @@
+import { WrappedEvent, EventType } from './types';
+declare class Node {
+    key: string;
+    value: WrappedEvent<EventType>[];
+    next?: Node;
+    prev?: Node;
+    constructor(key: string, value: WrappedEvent<EventType>[], next?: Node, prev?: Node);
+}
+export declare class TxEventCache {
+    maxTx: number;
+    size: number;
+    head?: Node;
+    tail?: Node;
+    cacheMap: {
+        [key: string]: Node;
+    };
+    constructor(maxTx?: number);
+    add(key: string, events: WrappedEvent<EventType>[]): void;
+    has(key: string): boolean;
+    get(key: string): WrappedEvent<EventType>[] | undefined;
+    detach(node: Node): void;
+    clear(): void;
+}
+export {};

package/lib/browser/events/txEventCache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxEventCache = void 0;
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+// lru cache
+class TxEventCache {
+    constructor(maxTx = 1024) {
+        this.maxTx = maxTx;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
+        if (existingNode) {
+            this.detach(existingNode);
+            this.size--;
+        }
+        else if (this.size === this.maxTx) {
+            delete this.cacheMap[this.tail.key];
+            this.detach(this.tail);
+            this.size--;
+        }
+        // Write to head of LinkedList
+        if (!this.head) {
+            this.head = this.tail = new Node(key, events);
+        }
+        else {
+            const node = new Node(key, events, this.head);
+            this.head.prev = node;
+            this.head = node;
+        }
+        // update cacheMap with LinkedList key and Node reference
+        this.cacheMap[key] = this.head;
+        this.size++;
+    }
+    has(key) {
+        return this.cacheMap.hasOwnProperty(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    detach(node) {
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+}
+exports.TxEventCache = TxEventCache;

package/lib/browser/events/types.d.ts

@@ -0,0 +1,104 @@
+/// <reference types="node" />
+import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
+import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord, SwapRecord, SpotMarketVaultDepositRecord, SignedMsgOrderRecord, DeleteUserRecord, InsuranceFundSwapRecord, TransferProtocolIfSharesToRevenuePoolRecord, LPMintRedeemRecord, LPSettleRecord, LPSwapRecord, LPBorrowLendDepositRecord } from '../types';
+import { EventEmitter } from 'events';
+export type EventSubscriptionOptions = {
+    address?: PublicKey;
+    eventTypes?: EventType[];
+    maxEventsPerType?: number;
+    orderBy?: EventSubscriptionOrderBy;
+    orderDir?: EventSubscriptionOrderDirection;
+    commitment?: Commitment;
+    maxTx?: number;
+    logProviderConfig?: LogProviderConfig;
+    untilTx?: TransactionSignature;
+};
+export declare const DefaultEventSubscriptionOptions: EventSubscriptionOptions;
+export type EventSubscriptionOrderBy = 'blockchain' | 'client';
+export type EventSubscriptionOrderDirection = 'asc' | 'desc';
+export type Event<T> = T & {
+    txSig: TransactionSignature;
+    slot: number;
+    txSigIndex: number;
+};
+export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
+    eventType: Type;
+};
+export type WrappedEvents = WrappedEvent<EventType>[];
+export type EventMap = {
+    DepositRecord: Event<DepositRecord>;
+    FundingPaymentRecord: Event<FundingPaymentRecord>;
+    LiquidationRecord: Event<LiquidationRecord>;
+    FundingRateRecord: Event<FundingRateRecord>;
+    OrderRecord: Event<OrderRecord>;
+    OrderActionRecord: Event<OrderActionRecord>;
+    SettlePnlRecord: Event<SettlePnlRecord>;
+    NewUserRecord: Event<NewUserRecord>;
+    InsuranceFundRecord: Event<InsuranceFundRecord>;
+    SpotInterestRecord: Event<SpotInterestRecord>;
+    InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
+    CurveRecord: Event<CurveRecord>;
+    SwapRecord: Event<SwapRecord>;
+    SpotMarketVaultDepositRecord: Event<SpotMarketVaultDepositRecord>;
+    SignedMsgOrderRecord: Event<SignedMsgOrderRecord>;
+    DeleteUserRecord: Event<DeleteUserRecord>;
+    InsuranceFundSwapRecord: Event<InsuranceFundSwapRecord>;
+    TransferProtocolIfSharesToRevenuePoolRecord: Event<TransferProtocolIfSharesToRevenuePoolRecord>;
+    LPSettleRecord: Event<LPSettleRecord>;
+    LPMintRedeemRecord: Event<LPMintRedeemRecord>;
+    LPSwapRecord: Event<LPSwapRecord>;
+};
+export type EventType = keyof EventMap;
+export type VelocityEvent = Event<DepositRecord> | Event<FundingPaymentRecord> | Event<LiquidationRecord> | Event<FundingRateRecord> | Event<OrderRecord> | Event<OrderActionRecord> | Event<SettlePnlRecord> | Event<NewUserRecord> | Event<InsuranceFundRecord> | Event<SpotInterestRecord> | Event<InsuranceFundStakeRecord> | Event<CurveRecord> | Event<SwapRecord> | Event<SpotMarketVaultDepositRecord> | Event<SignedMsgOrderRecord> | Event<DeleteUserRecord> | Event<InsuranceFundSwapRecord> | Event<TransferProtocolIfSharesToRevenuePoolRecord> | Event<LPSettleRecord> | Event<LPMintRedeemRecord> | Event<LPSwapRecord> | Event<LPBorrowLendDepositRecord> | Event<CuUsage>;
+/** @deprecated Use `VelocityEvent` instead. `DriftEvent` will be removed in a future major. */
+export type DriftEvent = VelocityEvent;
+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, 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 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 EventsServerLogProviderConfig = StreamingLogProviderConfig & {
+    type: 'events-server';
+    url: string;
+};
+export type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig | EventsServerLogProviderConfig;
+export type CuUsageEvent = {
+    name: 'CuUsage';
+    fields: [
+        {
+            name: 'instruction';
+            type: 'string';
+            index: false;
+        },
+        {
+            name: 'cuUsage';
+            type: 'u32';
+            index: false;
+        }
+    ];
+};
+export type CuUsage = {
+    instruction: string;
+    cuUsage: number;
+};

package/lib/browser/events/types.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEventSubscriptionOptions = void 0;
+exports.DefaultEventSubscriptionOptions = {
+    eventTypes: [
+        'DepositRecord',
+        'FundingPaymentRecord',
+        'LiquidationRecord',
+        'OrderRecord',
+        'OrderActionRecord',
+        'FundingRateRecord',
+        'NewUserRecord',
+        'SettlePnlRecord',
+        'InsuranceFundRecord',
+        'SpotInterestRecord',
+        'InsuranceFundStakeRecord',
+        'CurveRecord',
+        'SwapRecord',
+        'SpotMarketVaultDepositRecord',
+        'SignedMsgOrderRecord',
+        'DeleteUserRecord',
+        'InsuranceFundSwapRecord',
+        'TransferProtocolIfSharesToRevenuePoolRecord',
+        'LPMintRedeemRecord',
+        'LPSettleRecord',
+        'LPSwapRecord',
+    ],
+    maxEventsPerType: 4096,
+    orderBy: 'blockchain',
+    orderDir: 'asc',
+    commitment: 'confirmed',
+    maxTx: 4096,
+    logProviderConfig: {
+        type: 'websocket',
+    },
+};

package/lib/browser/events/webSocketLogProvider.d.ts

@@ -0,0 +1,24 @@
+/// <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;
+    private commitment;
+    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): Promise<boolean>;
+    setSubscription(callback: logProviderCallback): void;
+    isSubscribed(): boolean;
+    unsubscribe(external?: boolean): Promise<boolean>;
+    private setTimeout;
+}

package/lib/browser/events/webSocketLogProvider.js

@@ -0,0 +1,96 @@
+"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;
+        this.address = address;
+        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();
+        }
+    }
+    async subscribe(callback) {
+        if (this.subscriptionId != null) {
+            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;
+                clearTimeout(this.timeoutId);
+                this.setTimeout();
+                if (this.reconnectAttempts > 0) {
+                    console.log('Resetting reconnect attempts to 0');
+                }
+                this.reconnectAttempts = 0;
+            }
+            if (logs.err !== null) {
+                return;
+            }
+            callback(logs.signature, ctx.slot, logs.logs, undefined, undefined);
+        }, this.commitment);
+    }
+    isSubscribed() {
+        return this.subscriptionId != null;
+    }
+    async unsubscribe(external = false) {
+        this.isUnsubscribing = true;
+        this.externalUnsubscribe = external;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.subscriptionId != null) {
+            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;
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing || this.externalUnsubscribe) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                console.log(`webSocketLogProvider: 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);
+    }
+}
+exports.WebSocketLogProvider = WebSocketLogProvider;