@velocity-exchange/sdk 0.1.0 → 0.2.0

package/lib/browser/dlob/DLOBNode.d.ts

@@ -2,8 +2,10 @@
 import { BN } from '../isomorphic/anchor';
 import { MarketTypeStr, Order } from '../types';
 import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
+export type NodeOraclePriceData<T extends MarketTypeStr = MarketTypeStr> = T extends 'spot' ? OraclePriceData : MMOraclePriceData;
 export interface DLOBNode {
-    getPrice<T extends MarketTypeStr>(oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData, slot: number): BN;
+    getPrice<T extends MarketTypeStr>(oraclePriceData: NodeOraclePriceData<T>, slot: number): BN | undefined;
+    getPriceOrThrow<T extends MarketTypeStr>(oraclePriceData: NodeOraclePriceData<T>, slot: number): BN;
     isVammNode(): boolean;
     order: Order | undefined;
     isBaseFilled(): boolean;
@@ -23,7 +25,8 @@ export declare abstract class OrderNode implements DLOBNode {
     constructor(order: Order, userAccount: string, baseAssetAmount?: BN, isSignedMsg?: boolean);
     abstract getSortValue(order: Order): BN;
     getLabel(): string;
-    getPrice<T extends MarketTypeStr>(oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData, slot: number): BN;
+    getPrice<T extends MarketTypeStr>(oraclePriceData: NodeOraclePriceData<T>, slot: number): BN | undefined;
+    getPriceOrThrow<T extends MarketTypeStr>(oraclePriceData: NodeOraclePriceData<T>, slot: number): BN;
     isBaseFilled(): boolean;
     isVammNode(): boolean;
 }

package/lib/browser/dlob/DLOBNode.js

@@ -33,6 +33,13 @@ class OrderNode {
     getPrice(oraclePriceData, slot) {
         return (0, orders_1.getLimitPrice)(this.order, oraclePriceData, slot);
     }
+    getPriceOrThrow(oraclePriceData, slot) {
+        const price = this.getPrice(oraclePriceData, slot);
+        if (price === undefined) {
+            throw new Error(`OrderNode.getPrice: order ${this.order.orderId} has no limit price`);
+        }
+        return price;
+    }
     isBaseFilled() {
         return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
     }

package/lib/browser/dlob/DLOBSubscriber.js

@@ -29,7 +29,7 @@ class DLOBSubscriber {
                 this.eventEmitter.emit('update', this.dlob);
             }
             catch (e) {
-                this.eventEmitter.emit('error', e);
+                this.eventEmitter.emit('error', e instanceof Error ? e : new Error(String(e)));
             }
         }, this.updateFrequency);
     }
@@ -64,35 +64,39 @@ class DLOBSubscriber {
                 throw new Error('Either marketName or marketIndex and marketType must be provided');
             }
         }
-        let oraclePriceData;
         const isPerp = (0, types_1.isVariant)(marketType, 'perp');
         if (isPerp) {
-            const perpMarketAccount = this.velocityClient.getPerpMarketAccount(marketIndex);
-            oraclePriceData = this.velocityClient.getOracleDataForPerpMarket(perpMarketAccount.marketIndex);
-        }
-        else {
-            oraclePriceData =
-                this.velocityClient.getOracleDataForSpotMarket(marketIndex);
-        }
-        if (isPerp && includeVamm) {
-            if (fallbackL2Generators.length > 0) {
-                throw new Error('includeVamm can only be used if fallbackL2Generators is empty');
+            const perpMarketAccount = this.velocityClient.getPerpMarketAccountOrThrow(marketIndex);
+            const oraclePriceData = this.velocityClient.getMMOracleDataForPerpMarket(perpMarketAccount.marketIndex);
+            if (includeVamm) {
+                if (fallbackL2Generators.length > 0) {
+                    throw new Error('includeVamm can only be used if fallbackL2Generators is empty');
+                }
+                fallbackL2Generators = [
+                    (0, orderBookLevels_1.getVammL2Generator)({
+                        marketAccount: perpMarketAccount,
+                        mmOraclePriceData: this.velocityClient.getMMOracleDataForPerpMarket(marketIndex),
+                        numOrders: numVammOrders !== null && numVammOrders !== void 0 ? numVammOrders : depth,
+                        topOfBookQuoteAmounts: marketIndex < 3
+                            ? orderBookLevels_1.MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS
+                            : orderBookLevels_1.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
+                        latestSlot,
+                    }),
+                ];
             }
-            fallbackL2Generators = [
-                (0, orderBookLevels_1.getVammL2Generator)({
-                    marketAccount: this.velocityClient.getPerpMarketAccount(marketIndex),
-                    mmOraclePriceData: this.velocityClient.getMMOracleDataForPerpMarket(marketIndex),
-                    numOrders: numVammOrders !== null && numVammOrders !== void 0 ? numVammOrders : depth,
-                    topOfBookQuoteAmounts: marketIndex < 3
-                        ? orderBookLevels_1.MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS
-                        : orderBookLevels_1.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
-                    latestSlot,
-                }),
-            ];
+            return this.dlob.getL2({
+                marketIndex,
+                marketType: types_1.MarketType.PERP,
+                depth,
+                oraclePriceData,
+                slot: this.slotSource.getSlot(),
+                fallbackL2Generators: fallbackL2Generators,
+            });
         }
+        const oraclePriceData = this.velocityClient.getOracleDataForSpotMarket(marketIndex);
         return this.dlob.getL2({
             marketIndex,
-            marketType,
+            marketType: types_1.MarketType.SPOT,
             depth,
             oraclePriceData,
             slot: this.slotSource.getSlot(),
@@ -120,19 +124,20 @@ class DLOBSubscriber {
                 throw new Error('Either marketName or marketIndex and marketType must be provided');
             }
         }
-        let oraclePriceData;
         const isPerp = (0, types_1.isVariant)(marketType, 'perp');
         if (isPerp) {
-            oraclePriceData =
-                this.velocityClient.getOracleDataForPerpMarket(marketIndex);
-        }
-        else {
-            oraclePriceData =
-                this.velocityClient.getOracleDataForSpotMarket(marketIndex);
+            const oraclePriceData = this.velocityClient.getMMOracleDataForPerpMarket(marketIndex);
+            return this.dlob.getL3({
+                marketIndex,
+                marketType: types_1.MarketType.PERP,
+                oraclePriceData,
+                slot: this.slotSource.getSlot(),
+            });
         }
+        const oraclePriceData = this.velocityClient.getOracleDataForSpotMarket(marketIndex);
         return this.dlob.getL3({
             marketIndex,
-            marketType,
+            marketType: types_1.MarketType.SPOT,
             oraclePriceData,
             slot: this.slotSource.getSlot(),
         });

package/lib/browser/dlob/NodeList.js

@@ -45,9 +45,10 @@ class NodeList {
             !this.prependNode(currentNode.next, newNode)) {
             currentNode = currentNode.next;
         }
-        newNode.next = currentNode.next;
-        if (currentNode.next !== undefined) {
-            newNode.next.previous = newNode;
+        const nextNode = currentNode.next;
+        newNode.next = nextNode;
+        if (nextNode !== undefined) {
+            nextNode.previous = newNode;
         }
         currentNode.next = newNode;
         newNode.previous = currentNode;
@@ -69,16 +70,16 @@ class NodeList {
     }
     update(order, userAccount) {
         const orderId = getOrderSignature(order.orderId, userAccount);
-        if (this.nodeMap.has(orderId)) {
-            const node = this.nodeMap.get(orderId);
+        const node = this.nodeMap.get(orderId);
+        if (node !== undefined) {
             Object.assign(node.order, order);
             node.haveFilled = false;
         }
     }
     remove(order, userAccount) {
         const orderId = getOrderSignature(order.orderId, userAccount);
-        if (this.nodeMap.has(orderId)) {
-            const node = this.nodeMap.get(orderId);
+        const node = this.nodeMap.get(orderId);
+        if (node !== undefined) {
             if (node.next) {
                 node.next.previous = node.previous;
             }

package/lib/browser/dlob/orderBookLevels.js

@@ -28,13 +28,16 @@ const INDICATIVE_QUOTES_PUBKEY = 'inDNdu3ML4vG5LNExqcwuCQtLcCU8KfK5YM2qYV3JJz';
  */
 function* getL2GeneratorFromDLOBNodes(dlobNodes, oraclePriceData, slot) {
     for (const dlobNode of dlobNodes) {
+        if (!dlobNode.order) {
+            continue;
+        }
         const size = dlobNode.baseAssetAmount.sub(dlobNode.order.baseAssetAmountFilled);
         if (size.lte(numericConstants_1.ZERO)) {
             continue;
         }
         yield {
             size,
-            price: dlobNode.getPrice(oraclePriceData, slot),
+            price: dlobNode.getPriceOrThrow(oraclePriceData, slot),
             sources: dlobNode.userAccount == INDICATIVE_QUOTES_PUBKEY
                 ? { indicative: size }
                 : {
@@ -83,8 +86,9 @@ function createL2Levels(generator, depth) {
             const currentLevel = levels[levels.length - 1];
             currentLevel.size = currentLevel.size.add(size);
             for (const [source, size] of Object.entries(level.sources)) {
-                if (currentLevel.sources[source]) {
-                    currentLevel.sources[source] = currentLevel.sources[source].add(size);
+                const existingSize = currentLevel.sources[source];
+                if (existingSize) {
+                    currentLevel.sources[source] = existingSize.add(size);
                 }
                 else {
                     currentLevel.sources[source] = size;
@@ -102,7 +106,7 @@ function createL2Levels(generator, depth) {
 }
 exports.createL2Levels = createL2Levels;
 function getVammL2Generator({ marketAccount, mmOraclePriceData, numOrders, now = new anchor_1.BN(Math.floor(Date.now() / 1000)), topOfBookQuoteAmounts = [], latestSlot, }) {
-    const updatedAmm = (0, amm_1.calculateUpdatedAMM)(marketAccount.amm, marketAccount.totalExchangeFee, mmOraclePriceData);
+    const updatedAmm = (0, amm_1.calculateUpdatedAMM)(marketAccount.amm, mmOraclePriceData);
     const paused = (0, exchangeStatus_1.isOperationPaused)(marketAccount.pausedOperations, types_1.PerpOperation.AMM_FILL);
     let [openBids, openAsks] = paused
         ? [numericConstants_1.ZERO, numericConstants_1.ZERO]
@@ -208,8 +212,9 @@ function groupL2Levels(levels, grouping, direction, depth) {
             const currentLevel = cloneL2Level(groupedLevels[groupedLevels.length - 1]);
             currentLevel.size = currentLevel.size.add(size);
             for (const [source, size] of Object.entries(level.sources)) {
-                if (currentLevel.sources[source]) {
-                    currentLevel.sources[source] = currentLevel.sources[source].add(size);
+                const existingSize = currentLevel.sources[source];
+                if (existingSize) {
+                    currentLevel.sources[source] = existingSize.add(size);
                 }
                 else {
                     currentLevel.sources[source] = size;
@@ -238,12 +243,13 @@ const mergeByPrice = (bidsOrAsks) => {
     const merged = new Map();
     for (const level of bidsOrAsks) {
         const key = level.price.toString();
-        if (merged.has(key)) {
-            const existing = merged.get(key);
+        const existing = merged.get(key);
+        if (existing) {
             existing.size = existing.size.add(level.size);
             for (const [source, size] of Object.entries(level.sources)) {
-                if (existing.sources[source]) {
-                    existing.sources[source] = existing.sources[source].add(size);
+                const existingSize = existing.sources[source];
+                if (existingSize) {
+                    existing.sources[source] = existingSize.add(size);
                 }
                 else {
                     existing.sources[source] = size;
@@ -289,10 +295,11 @@ function uncrossL2(bids, asks, oraclePrice, oracleTwap5Min, markTwap5Min, groupi
         if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
             levels[levels.length - 1].size = levels[levels.length - 1].size.add(oldLevel.size);
             for (const [source, size] of Object.entries(oldLevel.sources)) {
-                if (levels[levels.length - 1].sources[source]) {
+                const existingSize = levels[levels.length - 1].sources[source];
+                if (existingSize) {
                     levels[levels.length - 1].sources = {
                         ...levels[levels.length - 1].sources,
-                        [source]: levels[levels.length - 1].sources[source].add(size),
+                        [source]: existingSize.add(size),
                     };
                 }
                 else {

package/lib/browser/events/eventList.js

@@ -37,7 +37,7 @@ class EventList {
                 currentNode = currentNode.next;
             }
             newNode.next = currentNode.next;
-            if (currentNode.next !== undefined) {
+            if (newNode.next !== undefined) {
                 newNode.next.prev = newNode;
             }
             else {
@@ -52,6 +52,9 @@ class EventList {
     }
     detach() {
         const node = this.tail;
+        if (node === undefined) {
+            return;
+        }
         if (node.prev !== undefined) {
             node.prev.next = node.next;
         }

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

@@ -22,13 +22,16 @@ export declare class EventSubscriber {
     private txEventCache;
     private awaitTxPromises;
     private awaitTxResolver;
-    private logProvider;
+    private _logProvider?;
     private _currentProviderType;
     eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
     private lastSeenSlot;
     private lastSeenBlockTime;
-    lastSeenTxSig: string;
+    lastSeenTxSig: string | undefined;
+    private get logProvider();
     constructor(connection: Connection, program: Program, options?: EventSubscriptionOptions);
+    private getLogProviderConfig;
+    private getEventTypes;
     get currentProviderType(): LogProviderType;
     private initializeLogProvider;
     private populateInitialEventListMap;

package/lib/browser/events/eventSubscriber.js

@@ -12,6 +12,12 @@ const sort_1 = require("./sort");
 const parse_1 = require("./parse");
 const eventsServerLogProvider_1 = require("./eventsServerLogProvider");
 class EventSubscriber {
+    get logProvider() {
+        if (!this._logProvider) {
+            throw new Error('EventSubscriber: logProvider accessed before initializeLogProvider()');
+        }
+        return this._logProvider;
+    }
     constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
         var _a;
         this.connection = connection;
@@ -24,18 +30,31 @@ class EventSubscriber {
         this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
         this.eventListMap = new Map();
         this.eventEmitter = new events_1.EventEmitter();
-        this._currentProviderType = this.options.logProviderConfig.type;
+        this._currentProviderType = this.getLogProviderConfig().type;
         this.initializeLogProvider();
     }
+    getLogProviderConfig() {
+        if (this.options.logProviderConfig === undefined) {
+            throw new Error('EventSubscriber: logProviderConfig is not set');
+        }
+        return this.options.logProviderConfig;
+    }
+    getEventTypes() {
+        if (this.options.eventTypes === undefined) {
+            throw new Error('EventSubscriber: eventTypes is not set');
+        }
+        return this.options.eventTypes;
+    }
     get currentProviderType() {
         return this._currentProviderType;
     }
     initializeLogProvider(subscribe = false) {
-        const logProviderConfig = this.options.logProviderConfig;
+        var _a, _b;
+        const logProviderConfig = this.getLogProviderConfig();
         if (this._currentProviderType === 'websocket') {
-            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
+            this._logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
             // @ts-ignore
-            this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
+            this.connection, this.address, (_a = this.options.commitment) !== null && _a !== void 0 ? _a : 'confirmed', logProviderConfig.resubTimeoutMs);
         }
         else if (this._currentProviderType === 'polling') {
             const frequency = 'frequency' in logProviderConfig
@@ -44,12 +63,12 @@ class EventSubscriber {
             const batchSize = 'batchSize' in logProviderConfig
                 ? logProviderConfig.batchSize
                 : logProviderConfig.fallbackBatchSize;
-            this.logProvider = new pollingLogProvider_1.PollingLogProvider(
+            this._logProvider = new pollingLogProvider_1.PollingLogProvider(
             // @ts-ignore
-            this.connection, this.address, this.options.commitment, frequency, batchSize);
+            this.connection, this.address, (_b = this.options.commitment) !== null && _b !== void 0 ? _b : 'confirmed', frequency, batchSize);
         }
         else if (this._currentProviderType === 'events-server') {
-            this.logProvider = new eventsServerLogProvider_1.EventsServerLogProvider(logProviderConfig.url, this.options.eventTypes, this.options.address ? this.options.address.toString() : undefined);
+            this._logProvider = new eventsServerLogProvider_1.EventsServerLogProvider(logProviderConfig.url, this.getEventTypes(), this.options.address ? this.options.address.toString() : undefined);
         }
         else {
             throw new Error(`Invalid log provider type: ${this._currentProviderType}`);
@@ -61,8 +80,16 @@ class EventSubscriber {
         }
     }
     populateInitialEventListMap() {
-        for (const eventType of this.options.eventTypes) {
-            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));
+        const maxEventsPerType = this.options.maxEventsPerType;
+        const orderBy = this.options.orderBy;
+        const orderDir = this.options.orderDir;
+        if (maxEventsPerType === undefined ||
+            orderBy === undefined ||
+            orderDir === undefined) {
+            throw new Error('EventSubscriber: maxEventsPerType, orderBy and orderDir must be set');
+        }
+        for (const eventType of this.getEventTypes()) {
+            this.eventListMap.set(eventType, new eventList_1.EventList(eventType, maxEventsPerType, (0, sort_1.getSortFn)(orderBy, orderDir), orderDir));
         }
     }
     /**
@@ -87,22 +114,27 @@ class EventSubscriber {
         this._currentProviderType = nextProviderType;
     }
     async subscribe() {
+        var _a;
         try {
             if (this.logProvider.isSubscribed()) {
                 return true;
             }
             this.populateInitialEventListMap();
-            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');
+            if (this.getLogProviderConfig().type === 'websocket' ||
+                this.getLogProviderConfig().type === 'events-server') {
+                const logProviderConfig = this.getLogProviderConfig();
+                // `maxReconnectAttempts` is optional; when unset the original
+                // `reconnectAttempts > undefined` comparison was always false, so
+                // fall back to Infinity to preserve that never-trigger behavior.
+                const maxReconnectAttempts = (_a = logProviderConfig.maxReconnectAttempts) !== null && _a !== void 0 ? _a : Infinity;
+                const eventEmitter = this.logProvider.eventEmitter;
+                if (eventEmitter) {
+                    eventEmitter.on('reconnect', async (reconnectAttempts) => {
+                        if (reconnectAttempts > maxReconnectAttempts) {
+                            console.log(`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${maxReconnectAttempts}, reconnecting...`);
+                            eventEmitter.removeAllListeners('reconnect');
                             await this.unsubscribe();
-                            this.updateFallbackProviderType(reconnectAttempts, logProviderConfig.maxReconnectAttempts);
+                            this.updateFallbackProviderType(reconnectAttempts, maxReconnectAttempts);
                             this.initializeLogProvider(true);
                         }
                     });
@@ -125,7 +157,11 @@ class EventSubscriber {
         }
         const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs, txSigIndex);
         for (const wrappedEvent of wrappedEvents) {
-            this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+            const eventList = this.eventListMap.get(wrappedEvent.eventType);
+            if (eventList === undefined) {
+                throw new Error(`EventSubscriber: no EventList for eventType ${wrappedEvent.eventType}`);
+            }
+            eventList.insert(wrappedEvent);
         }
         // dont emit event till we've added all the events to the eventListMap
         for (const wrappedEvent of wrappedEvents) {
@@ -133,7 +169,10 @@ class EventSubscriber {
         }
         if (this.awaitTxPromises.has(txSig)) {
             this.awaitTxPromises.delete(txSig);
-            this.awaitTxResolver.get(txSig)();
+            const resolver = this.awaitTxResolver.get(txSig);
+            if (resolver !== undefined) {
+                resolver();
+            }
             this.awaitTxResolver.delete(txSig);
         }
         if (!this.lastSeenSlot || slot > this.lastSeenSlot) {
@@ -141,7 +180,8 @@ class EventSubscriber {
             this.lastSeenSlot = slot;
         }
         if (this.lastSeenBlockTime === undefined ||
-            mostRecentBlockTime > this.lastSeenBlockTime) {
+            (mostRecentBlockTime !== undefined &&
+                mostRecentBlockTime > this.lastSeenBlockTime)) {
             this.lastSeenBlockTime = mostRecentBlockTime;
         }
         this.txEventCache.add(txSig, wrappedEvents);
@@ -153,7 +193,11 @@ class EventSubscriber {
         let txFetched = 0;
         let beforeTx = undefined;
         const untilTx = this.options.untilTx;
-        while (txFetched < this.options.maxTx) {
+        const maxTx = this.options.maxTx;
+        if (maxTx === undefined) {
+            throw new Error('EventSubscriber: maxTx is not set');
+        }
+        while (txFetched < maxTx) {
             const response = await (0, fetchLogs_1.fetchLogs)(
             // @ts-ignore
             this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
@@ -198,8 +242,9 @@ class EventSubscriber {
         return records;
     }
     awaitTx(txSig) {
-        if (this.awaitTxPromises.has(txSig)) {
-            return this.awaitTxPromises.get(txSig);
+        const existingPromise = this.awaitTxPromises.get(txSig);
+        if (existingPromise !== undefined) {
+            return existingPromise;
         }
         if (this.txEventCache.has(txSig)) {
             return Promise.resolve();
@@ -220,7 +265,11 @@ class EventSubscriber {
      * @param eventType
      */
     getEventsArray(eventType) {
-        return this.eventListMap.get(eventType).toArray();
+        const eventList = this.eventListMap.get(eventType);
+        if (eventList === undefined) {
+            throw new Error(`EventSubscriber: no EventList for eventType ${eventType}`);
+        }
+        return eventList.toArray();
     }
     getEventsByTx(txSig) {
         return this.txEventCache.get(txSig);

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

@@ -12,7 +12,7 @@ export declare class EventsServerLogProvider implements LogProvider {
     private lastHeartbeat;
     private timeoutId?;
     private reconnectAttempts;
-    eventEmitter?: EventEmitter;
+    eventEmitter: EventEmitter;
     constructor(url: string, eventTypes: EventType[], userAccount?: string);
     isSubscribed(): boolean;
     subscribe(callback: logProviderCallback): Promise<boolean>;

package/lib/browser/events/eventsServerLogProvider.js

@@ -30,22 +30,23 @@ class EventsServerLogProvider {
         if (this.ws !== undefined) {
             return true;
         }
-        this.ws = new WebSocketImpl(this.url);
+        const ws = new WebSocketImpl(this.url);
+        this.ws = ws;
         this.callback = callback;
-        this.ws.addEventListener('open', () => {
+        ws.addEventListener('open', () => {
             for (const channel of this.eventTypes) {
                 const subscribeMessage = {
                     type: 'subscribe',
                     channel: channel,
                 };
                 if (this.userAccount) {
-                    subscribeMessage['user'] = this.userAccount;
+                    subscribeMessage.user = this.userAccount;
                 }
-                this.ws.send(JSON.stringify(subscribeMessage));
+                ws.send(JSON.stringify(subscribeMessage));
             }
             this.reconnectAttempts = 0;
         });
-        this.ws.addEventListener('message', (data) => {
+        ws.addEventListener('message', (data) => {
             try {
                 if (!this.isUnsubscribing) {
                     clearTimeout(this.timeoutId);
@@ -64,6 +65,9 @@ class EventsServerLogProvider {
                     return;
                 }
                 const event = JSON.parse(parsedData.data);
+                if (this.callback === undefined) {
+                    return;
+                }
                 this.callback(event.txSig, event.slot, [
                     'Program vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P invoke [1]',
                     event.rawLog,
@@ -74,10 +78,10 @@ class EventsServerLogProvider {
                 console.error('Error parsing message:', error);
             }
         });
-        this.ws.addEventListener('close', () => {
+        ws.addEventListener('close', () => {
             console.log('eventsServerLogProvider: WebSocket closed');
         });
-        this.ws.addEventListener('error', (error) => {
+        ws.addEventListener('error', (error) => {
             console.error('eventsServerLogProvider: WebSocket error:', error);
         });
         this.setTimeout();
@@ -110,10 +114,13 @@ class EventsServerLogProvider {
             if (timeSinceLastHeartbeat >
                 EVENT_SERVER_HEARTBEAT_INTERVAL_MS * ALLOWED_MISSED_HEARTBEATS) {
                 console.log(`eventServerLogProvider: No heartbeat in ${timeSinceLastHeartbeat}ms, resubscribing on attempt ${this.reconnectAttempts + 1}`);
+                const callback = this.callback;
                 await this.unsubscribe();
                 this.reconnectAttempts++;
                 this.eventEmitter.emit('reconnect', this.reconnectAttempts);
-                this.subscribe(this.callback);
+                if (callback !== undefined) {
+                    this.subscribe(callback);
+                }
             }
         }, EVENT_SERVER_HEARTBEAT_INTERVAL_MS * 2);
     }

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

@@ -14,7 +14,7 @@ type FetchLogsResponse = {
     transactionLogs: Log[];
     mostRecentBlockTime: number | undefined;
 };
-export declare function fetchLogs(connection: Connection, address: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature, limit?: number, batchSize?: number): Promise<FetchLogsResponse>;
+export declare function fetchLogs(connection: Connection, address: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature, limit?: number, batchSize?: number): Promise<FetchLogsResponse | undefined>;
 export declare function fetchTransactionLogs(connection: Connection, signatures: TransactionSignature[], finality: Finality): Promise<Log[]>;
 export declare class LogParser {
     private program;

package/lib/browser/events/fetchLogs.js

@@ -4,13 +4,15 @@ exports.LogParser = exports.fetchTransactionLogs = exports.fetchLogs = void 0;
 const promiseTimeout_1 = require("../util/promiseTimeout");
 const parse_1 = require("./parse");
 function mapTransactionResponseToLog(transaction) {
+    var _a, _b;
     return {
         txSig: transaction.transaction.signatures[0],
         slot: transaction.slot,
-        logs: transaction.meta.logMessages,
+        logs: (_b = (_a = transaction.meta) === null || _a === void 0 ? void 0 : _a.logMessages) !== null && _b !== void 0 ? _b : [],
     };
 }
 async function fetchLogs(connection, address, finality, beforeTx, untilTx, limit, batchSize = 25) {
+    var _a;
     const signatures = await connection.getSignaturesForAddress(address, {
         before: beforeTx,
         until: untilTx,
@@ -33,7 +35,7 @@ async function fetchLogs(connection, address, finality, beforeTx, untilTx, limit
         mostRecentTx: mostRecent.signature,
         earliestSlot: earliest.slot,
         mostRecentSlot: mostRecent.slot,
-        mostRecentBlockTime: mostRecent.blockTime,
+        mostRecentBlockTime: (_a = mostRecent.blockTime) !== null && _a !== void 0 ? _a : undefined,
     };
 }
 exports.fetchLogs = fetchLogs;

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

@@ -6,7 +6,7 @@ export declare class PollingLogProvider implements LogProvider {
     private frequency;
     private batchSize?;
     private finality;
-    private intervalId;
+    private intervalId?;
     private mostRecentSeenTx?;
     private mutex;
     private firstFetch;

package/lib/browser/events/pollingLogProvider.js

@@ -8,6 +8,7 @@ class PollingLogProvider {
         this.address = address;
         this.frequency = frequency;
         this.batchSize = batchSize;
+        this.mutex = 0;
         this.firstFetch = true;
         this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
     }

package/lib/browser/events/txEventCache.js

@@ -23,8 +23,12 @@ class TxEventCache {
             this.size--;
         }
         else if (this.size === this.maxTx) {
-            delete this.cacheMap[this.tail.key];
-            this.detach(this.tail);
+            const tail = this.tail;
+            if (tail === undefined) {
+                throw new Error('TxEventCache.add: cache at capacity but tail is unset');
+            }
+            delete this.cacheMap[tail.key];
+            this.detach(tail);
             this.size--;
         }
         // Write to head of LinkedList