@velocity-exchange/sdk 0.0.1

package/lib/node/events/eventSubscriber.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriber = void 0;
+const types_1 = require("./types");
+const txEventCache_1 = require("./txEventCache");
+const eventList_1 = require("./eventList");
+const pollingLogProvider_1 = require("./pollingLogProvider");
+const fetchLogs_1 = require("./fetchLogs");
+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;
+        this.connection = connection;
+        this.program = program;
+        this.options = options;
+        this.awaitTxPromises = new Map();
+        this.awaitTxResolver = new Map();
+        this.options = Object.assign({}, types_1.DefaultEventSubscriptionOptions, options);
+        this.address = (_a = this.options.address) !== null && _a !== void 0 ? _a : program.programId;
+        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.initializeLogProvider();
+    }
+    get currentProviderType() {
+        return this._currentProviderType;
+    }
+    initializeLogProvider(subscribe = false) {
+        const logProviderConfig = this.options.logProviderConfig;
+        if (this._currentProviderType === 'websocket') {
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
+        }
+        else if (this._currentProviderType === 'polling') {
+            const frequency = 'frequency' in logProviderConfig
+                ? logProviderConfig.frequency
+                : logProviderConfig.fallbackFrequency;
+            const batchSize = 'batchSize' in logProviderConfig
+                ? logProviderConfig.batchSize
+                : logProviderConfig.fallbackBatchSize;
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment, 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);
+        }
+        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() {
+        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));
+        }
+    }
+    /**
+     * 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' ||
+                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, txSigIndex) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime, this._currentProviderType === 'events-server', txSigIndex);
+            }, true);
+            return true;
+        }
+        catch (e) {
+            console.error('Error fetching previous txs in event subscriber');
+            console.error(e);
+            return false;
+        }
+    }
+    handleTxLogs(txSig, slot, logs, mostRecentBlockTime, fromEventsServer = false, txSigIndex = undefined) {
+        if (!fromEventsServer && this.txEventCache.has(txSig)) {
+            return;
+        }
+        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs, txSigIndex);
+        for (const wrappedEvent of wrappedEvents) {
+            this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+        }
+        // dont emit event till we've added all the events to the eventListMap
+        for (const wrappedEvent of wrappedEvents) {
+            this.eventEmitter.emit('newEvent', wrappedEvent);
+        }
+        if (this.awaitTxPromises.has(txSig)) {
+            this.awaitTxPromises.delete(txSig);
+            this.awaitTxResolver.get(txSig)();
+            this.awaitTxResolver.delete(txSig);
+        }
+        if (!this.lastSeenSlot || slot > this.lastSeenSlot) {
+            this.lastSeenTxSig = txSig;
+            this.lastSeenSlot = slot;
+        }
+        if (this.lastSeenBlockTime === undefined ||
+            mostRecentBlockTime > this.lastSeenBlockTime) {
+            this.lastSeenBlockTime = mostRecentBlockTime;
+        }
+        this.txEventCache.add(txSig, wrappedEvents);
+    }
+    async fetchPreviousTx(fetchMax) {
+        if (!this.options.untilTx && !fetchMax) {
+            return;
+        }
+        let txFetched = 0;
+        let beforeTx = undefined;
+        const untilTx = this.options.untilTx;
+        while (txFetched < this.options.maxTx) {
+            const response = await (0, fetchLogs_1.fetchLogs)(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+            if (response === undefined) {
+                break;
+            }
+            txFetched += response.transactionLogs.length;
+            beforeTx = response.earliestTx;
+            for (const { txSig, slot, logs } of response.transactionLogs) {
+                this.handleTxLogs(txSig, slot, logs, response.mostRecentBlockTime);
+            }
+        }
+    }
+    async unsubscribe() {
+        this.eventListMap.clear();
+        this.txEventCache.clear();
+        this.awaitTxPromises.clear();
+        this.awaitTxResolver.clear();
+        return await this.logProvider.unsubscribe(true);
+    }
+    parseEventsFromLogs(txSig, slot, logs, txSigIndex) {
+        const records = [];
+        // @ts-ignore
+        const events = (0, parse_1.parseLogs)(this.program, logs);
+        let runningEventIndex = 0;
+        for (const event of events) {
+            // @coral-xyz/anchor 0.32+ converts IDL names to camelCase; normalize
+            // back to PascalCase so EventType keys remain consistent.
+            const pascalName = event.name.charAt(0).toUpperCase() + event.name.slice(1);
+            // @ts-ignore
+            const expectRecordType = this.eventListMap.has(pascalName);
+            if (expectRecordType) {
+                event.data.txSig = txSig;
+                event.data.slot = slot;
+                event.data.eventType = pascalName;
+                event.data.txSigIndex =
+                    txSigIndex !== undefined ? txSigIndex : runningEventIndex;
+                records.push(event.data);
+            }
+            runningEventIndex++;
+        }
+        return records;
+    }
+    awaitTx(txSig) {
+        if (this.awaitTxPromises.has(txSig)) {
+            return this.awaitTxPromises.get(txSig);
+        }
+        if (this.txEventCache.has(txSig)) {
+            return Promise.resolve();
+        }
+        const promise = new Promise((resolve) => {
+            this.awaitTxResolver.set(txSig, resolve);
+        });
+        this.awaitTxPromises.set(txSig, promise);
+        return promise;
+    }
+    getEventList(eventType) {
+        return this.eventListMap.get(eventType);
+    }
+    /**
+     * This requires the EventList be cast to an array, which requires reallocation of memory.
+     * Would bias to using getEventList over getEvents
+     *
+     * @param eventType
+     */
+    getEventsArray(eventType) {
+        return this.eventListMap.get(eventType).toArray();
+    }
+    getEventsByTx(txSig) {
+        return this.txEventCache.get(txSig);
+    }
+}
+exports.EventSubscriber = EventSubscriber;

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

@@ -0,0 +1,22 @@
+/// <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;
+}
+//# sourceMappingURL=eventsServerLogProvider.d.ts.map

package/lib/node/events/eventsServerLogProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventsServerLogProvider.d.ts","sourceRoot":"","sources":["../../../src/events/eventsServerLogProvider.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAatC,qBAAa,uBAAwB,YAAW,WAAW;IAWzD,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAZ9B,OAAO,CAAC,EAAE,CAAC,CAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,CAAsB;IACvC,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,SAAS,CAAC,CAAgC;IAClD,OAAO,CAAC,iBAAiB,CAAK;IAC9B,YAAY,CAAC,EAAE,YAAY,CAAC;gBAGV,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,SAAS,EAAE,EACvB,WAAW,CAAC,EAAE,MAAM;IAK/B,YAAY,IAAI,OAAO;IAIjB,SAAS,CAAC,QAAQ,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAwE1D,WAAW,CAAC,QAAQ,UAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAkB5D,OAAO,CAAC,UAAU;CAwBlB"}

package/lib/node/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/node/events/fetchLogs.d.ts

@@ -0,0 +1,26 @@
+import { Program } from '../isomorphic/anchor';
+import { Connection, Finality, PublicKey, TransactionResponse, TransactionSignature } from '@solana/web3.js';
+import { WrappedEvents } from './types';
+type Log = {
+    txSig: TransactionSignature;
+    slot: number;
+    logs: string[];
+};
+type FetchLogsResponse = {
+    earliestTx: string;
+    mostRecentTx: string;
+    earliestSlot: number;
+    mostRecentSlot: number;
+    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 fetchTransactionLogs(connection: Connection, signatures: TransactionSignature[], finality: Finality): Promise<Log[]>;
+export declare class LogParser {
+    private program;
+    constructor(program: Program);
+    parseEventsFromTransaction(transaction: TransactionResponse): WrappedEvents;
+    parseEventsFromLogs(event: Log): WrappedEvents;
+}
+export {};
+//# sourceMappingURL=fetchLogs.d.ts.map

package/lib/node/events/fetchLogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchLogs.d.ts","sourceRoot":"","sources":["../../../src/events/fetchLogs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EACN,UAAU,EACV,QAAQ,EACR,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EAEpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIxC,KAAK,GAAG,GAAG;IAAE,KAAK,EAAE,oBAAoB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACzE,KAAK,iBAAiB,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,GAAG,EAAE,CAAC;IACvB,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,CAAC;AAYF,wBAAsB,SAAS,CAC9B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,CAAC,EAAE,oBAAoB,EAC/B,OAAO,CAAC,EAAE,oBAAoB,EAC9B,KAAK,CAAC,EAAE,MAAM,EACd,SAAS,SAAK,GACZ,OAAO,CAAC,iBAAiB,CAAC,CAgD5B;AAED,wBAAsB,oBAAoB,CACzC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,oBAAoB,EAAE,EAClC,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,GAAG,EAAE,CAAC,CAgChB;AASD,qBAAa,SAAS;IACrB,OAAO,CAAC,OAAO,CAAU;gBAEb,OAAO,EAAE,OAAO;IAIrB,0BAA0B,CAChC,WAAW,EAAE,mBAAmB,GAC9B,aAAa;IAMT,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,aAAa;CAiBrD"}

package/lib/node/events/fetchLogs.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogParser = exports.fetchTransactionLogs = exports.fetchLogs = void 0;
+const promiseTimeout_1 = require("../util/promiseTimeout");
+const parse_1 = require("./parse");
+function mapTransactionResponseToLog(transaction) {
+    return {
+        txSig: transaction.transaction.signatures[0],
+        slot: transaction.slot,
+        logs: transaction.meta.logMessages,
+    };
+}
+async function fetchLogs(connection, address, finality, beforeTx, untilTx, limit, batchSize = 25) {
+    const signatures = await connection.getSignaturesForAddress(address, {
+        before: beforeTx,
+        until: untilTx,
+        limit,
+    }, finality);
+    const sortedSignatures = signatures.sort((a, b) => a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1);
+    const filteredSignatures = sortedSignatures.filter((signature) => !signature.err);
+    if (filteredSignatures.length === 0) {
+        return undefined;
+    }
+    const chunkedSignatures = chunk(filteredSignatures, batchSize);
+    const transactionLogs = (await Promise.all(chunkedSignatures.map(async (chunk) => {
+        return await fetchTransactionLogs(connection, chunk.map((confirmedSignature) => confirmedSignature.signature), finality);
+    }))).flat();
+    const earliest = filteredSignatures[0];
+    const mostRecent = filteredSignatures[filteredSignatures.length - 1];
+    return {
+        transactionLogs: transactionLogs,
+        earliestTx: earliest.signature,
+        mostRecentTx: mostRecent.signature,
+        earliestSlot: earliest.slot,
+        mostRecentSlot: mostRecent.slot,
+        mostRecentBlockTime: mostRecent.blockTime,
+    };
+}
+exports.fetchLogs = fetchLogs;
+async function fetchTransactionLogs(connection, signatures, finality) {
+    const requests = new Array();
+    for (const signature of signatures) {
+        const args = [
+            signature,
+            { commitment: finality, maxSupportedTransactionVersion: 0 },
+        ];
+        requests.push({
+            methodName: 'getTransaction',
+            args,
+        });
+    }
+    const rpcResponses = await (0, promiseTimeout_1.promiseTimeout)(
+    // @ts-ignore
+    connection._rpcBatchRequest(requests), 10 * 1000 // 10 second timeout
+    );
+    if (rpcResponses === null) {
+        return Promise.reject('RPC request timed out fetching transactions');
+    }
+    const logs = new Array();
+    for (const rpcResponse of rpcResponses) {
+        if (rpcResponse.result) {
+            logs.push(mapTransactionResponseToLog(rpcResponse.result));
+        }
+    }
+    return logs;
+}
+exports.fetchTransactionLogs = fetchTransactionLogs;
+function chunk(array, size) {
+    return new Array(Math.ceil(array.length / size))
+        .fill(null)
+        .map((_, index) => index * size)
+        .map((begin) => array.slice(begin, begin + size));
+}
+class LogParser {
+    constructor(program) {
+        this.program = program;
+    }
+    parseEventsFromTransaction(transaction) {
+        const transactionLogObject = mapTransactionResponseToLog(transaction);
+        return this.parseEventsFromLogs(transactionLogObject);
+    }
+    parseEventsFromLogs(event) {
+        const records = [];
+        if (!event.logs)
+            return records;
+        let runningEventIndex = 0;
+        for (const eventLog of (0, parse_1.parseLogs)(this.program, event.logs)) {
+            eventLog.data.txSig = event.txSig;
+            eventLog.data.slot = event.slot;
+            eventLog.data.eventType = eventLog.name;
+            eventLog.data.txSigIndex = runningEventIndex;
+            // @ts-ignore
+            records.push(eventLog.data);
+            runningEventIndex++;
+        }
+        return records;
+    }
+}
+exports.LogParser = LogParser;

package/lib/node/events/parse.d.ts

@@ -0,0 +1,9 @@
+import { Program, Event } from '../isomorphic/anchor';
+import { CuUsageEvent } from './types';
+export declare function parseLogs(program: Program, logs: string[], programId?: string): Event[];
+export declare function parseLogsWithRaw(program: Program, logs: string[], programId?: string): {
+    events: Event[];
+    rawLogs: string[];
+};
+export declare function parseLogsForCuUsage(logs: string[], programId?: string): Event<any, CuUsageEvent>[];
+//# sourceMappingURL=parse.d.ts.map

package/lib/node/events/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/events/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAUvC,wBAAgB,SAAS,CACxB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,SAAiB,GACxB,KAAK,EAAE,CAGT;AAED,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,SAAiB,GACxB;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA2BxC;AAsGD,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,SAAiB,GACxB,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,EAAE,CAmC5B"}