@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/node/driftClientConfig.d.ts

@@ -0,0 +1,49 @@
+import { Commitment, ConfirmOptions, Connection, PublicKey, TransactionVersion } from '@solana/web3.js';
+import { IWallet, TxParams } from './types';
+import { OracleInfo } from './oracles/types';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { DriftEnv } from './config';
+import { TxSender } from './tx/types';
+import { TxHandler, TxHandlerConfig } from './tx/txHandler';
+import { DelistedMarketSetting, GrpcConfigs } from './accounts/types';
+export type DriftClientConfig = {
+    connection: Connection;
+    wallet: IWallet;
+    env?: DriftEnv;
+    programID?: PublicKey;
+    swiftID?: PublicKey;
+    accountSubscription?: DriftClientSubscriptionConfig;
+    opts?: ConfirmOptions;
+    txSender?: TxSender;
+    txHandler?: TxHandler;
+    subAccountIds?: number[];
+    activeSubAccountId?: number;
+    perpMarketIndexes?: number[];
+    spotMarketIndexes?: number[];
+    marketLookupTable?: PublicKey;
+    oracleInfos?: OracleInfo[];
+    userStats?: boolean;
+    authority?: PublicKey;
+    includeDelegates?: boolean;
+    authoritySubAccountMap?: Map<string, number[]>;
+    skipLoadUsers?: boolean;
+    txVersion?: TransactionVersion;
+    txParams?: TxParams;
+    enableMetricsEvents?: boolean;
+    txHandlerConfig?: TxHandlerConfig;
+    delistedMarketSetting?: DelistedMarketSetting;
+};
+export type DriftClientSubscriptionConfig = {
+    type: 'grpc';
+    grpcConfigs: GrpcConfigs;
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+} | {
+    type: 'websocket';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    commitment?: Commitment;
+} | {
+    type: 'polling';
+    accountLoader: BulkAccountLoader;
+};

package/lib/node/driftClientConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { EventType, EventMap, EventSubscriptionOrderDirection, SortFn } from './types';
+declare class Node<Type extends EventType, Event extends EventMap[Type]> {
+    event: Event;
+    next?: Node<Type, Event>;
+    prev?: Node<Type, Event>;
+    constructor(event: Event, next?: Node<Type, Event>, prev?: Node<Type, Event>);
+}
+export declare class EventList<Type extends EventType> {
+    eventType: Type;
+    maxSize: number;
+    private sortFn;
+    private orderDirection;
+    size: number;
+    head?: Node<Type, EventMap[Type]>;
+    tail?: Node<Type, EventMap[Type]>;
+    constructor(eventType: Type, maxSize: number, sortFn: SortFn, orderDirection: EventSubscriptionOrderDirection);
+    insert(event: EventMap[Type]): void;
+    detach(): void;
+    toArray(): EventMap[Type][];
+    [Symbol.iterator](): Generator<EventMap[Type], void, unknown>;
+}
+export {};

package/lib/node/events/eventList.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventList = void 0;
+class Node {
+    constructor(event, next, prev) {
+        this.event = event;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+class EventList {
+    constructor(eventType, maxSize, sortFn, orderDirection) {
+        this.eventType = eventType;
+        this.maxSize = maxSize;
+        this.sortFn = sortFn;
+        this.orderDirection = orderDirection;
+        this.size = 0;
+    }
+    insert(event) {
+        this.size++;
+        const newNode = new Node(event);
+        if (this.head === undefined) {
+            this.head = this.tail = newNode;
+            return;
+        }
+        if (this.sortFn(this.head.event, newNode.event) ===
+            (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+            this.head.prev = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+        }
+        else {
+            let currentNode = this.head;
+            while (currentNode.next !== undefined &&
+                this.sortFn(currentNode.next.event, newNode.event) !==
+                    (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+                currentNode = currentNode.next;
+            }
+            newNode.next = currentNode.next;
+            if (currentNode.next !== undefined) {
+                newNode.next.prev = newNode;
+            }
+            else {
+                this.tail = newNode;
+            }
+            currentNode.next = newNode;
+            newNode.prev = currentNode;
+        }
+        if (this.size > this.maxSize) {
+            this.detach();
+        }
+    }
+    detach() {
+        const node = this.tail;
+        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;
+        }
+        this.size--;
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.event;
+            node = node.next;
+        }
+    }
+}
+exports.EventList = EventList;

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

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { Connection, TransactionSignature } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+import { EventSubscriptionOptions, EventType, WrappedEvents, EventMap, EventSubscriberEvents } from './types';
+import { EventList } from './eventList';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+export declare class EventSubscriber {
+    private connection;
+    private program;
+    private options;
+    private address;
+    private eventListMap;
+    private txEventCache;
+    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>;
+    unsubscribe(): Promise<boolean>;
+    private parseEventsFromLogs;
+    awaitTx(txSig: TransactionSignature): Promise<void>;
+    getEventList<Type extends keyof EventMap>(eventType: Type): EventList<Type>;
+    /**
+     * This requires the EventList be cast to an array, which requires reallocation of memory.
+     * Would bias to using getEventList over getEvents
+     *
+     * @param eventType
+     */
+    getEventsArray<Type extends EventType>(eventType: Type): EventMap[Type][];
+    getEventsByTx(txSig: TransactionSignature): WrappedEvents | undefined;
+}

package/lib/node/events/eventSubscriber.js

@@ -0,0 +1,223 @@
+"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();
+    }
+    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) {
+            // @ts-ignore
+            const expectRecordType = this.eventListMap.has(event.name);
+            if (expectRecordType) {
+                event.data.txSig = txSig;
+                event.data.slot = slot;
+                event.data.eventType = event.name;
+                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,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/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,25 @@
+import { Program } from '@coral-xyz/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 {};