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

package/src/driftClientConfig.ts

@@ -0,0 +1,60 @@
+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; // explicitly pass an authority if signer is delegate
+	includeDelegates?: boolean; // flag for whether to load delegate accounts as well
+	authoritySubAccountMap?: Map<string, number[]>; // if passed this will override subAccountIds and includeDelegates
+	skipLoadUsers?: boolean; // if passed to constructor, no user accounts will be loaded. they will load if updateWallet is called afterwards.
+	txVersion?: TransactionVersion; // which tx version to use
+	txParams?: TxParams; // default tx params to use
+	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/src/events/eventList.ts

@@ -0,0 +1,97 @@
+import {
+	EventType,
+	EventMap,
+	EventSubscriptionOrderDirection,
+	SortFn,
+} from './types';
+
+class Node<Type extends EventType, Event extends EventMap[Type]> {
+	constructor(
+		public event: Event,
+		public next?: Node<Type, Event>,
+		public prev?: Node<Type, Event>
+	) {}
+}
+
+export class EventList<Type extends EventType> {
+	size = 0;
+	head?: Node<Type, EventMap[Type]>;
+	tail?: Node<Type, EventMap[Type]>;
+
+	public constructor(
+		public eventType: Type,
+		public maxSize: number,
+		private sortFn: SortFn,
+		private orderDirection: EventSubscriptionOrderDirection
+	) {}
+
+	public insert(event: EventMap[Type]): void {
+		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(): void {
+		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(): EventMap[Type][] {
+		return Array.from(this);
+	}
+
+	*[Symbol.iterator]() {
+		let node = this.head;
+		while (node) {
+			yield node.event;
+			node = node.next;
+		}
+	}
+}

package/src/events/eventSubscriber.ts

@@ -0,0 +1,364 @@
+import { Connection, PublicKey, TransactionSignature } from '@solana/web3.js';
+import { Program } from '@coral-xyz/anchor';
+import {
+	DefaultEventSubscriptionOptions,
+	EventSubscriptionOptions,
+	EventType,
+	WrappedEvents,
+	EventMap,
+	LogProvider,
+	EventSubscriberEvents,
+	WebSocketLogProviderConfig,
+	EventsServerLogProviderConfig,
+	LogProviderType,
+	StreamingLogProviderConfig,
+	PollingLogProviderConfig,
+} from './types';
+import { TxEventCache } from './txEventCache';
+import { EventList } from './eventList';
+import { PollingLogProvider } from './pollingLogProvider';
+import { fetchLogs } from './fetchLogs';
+import { WebSocketLogProvider } from './webSocketLogProvider';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { getSortFn } from './sort';
+import { parseLogs } from './parse';
+import { EventsServerLogProvider } from './eventsServerLogProvider';
+
+export class EventSubscriber {
+	private address: PublicKey;
+	private eventListMap: Map<EventType, EventList<EventType>>;
+	private txEventCache: TxEventCache;
+	private awaitTxPromises = new Map<string, Promise<void>>();
+	private awaitTxResolver = new Map<string, () => void>();
+	private logProvider: LogProvider;
+	private currentProviderType: LogProviderType;
+	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+	private lastSeenSlot: number;
+	private lastSeenBlockTime: number | undefined;
+	public lastSeenTxSig: string;
+
+	public constructor(
+		private connection: Connection,
+		private program: Program,
+		private options: EventSubscriptionOptions = DefaultEventSubscriptionOptions
+	) {
+		this.options = Object.assign({}, DefaultEventSubscriptionOptions, options);
+		this.address = this.options.address ?? program.programId;
+		this.txEventCache = new TxEventCache(this.options.maxTx);
+		this.eventListMap = new Map<EventType, EventList<EventType>>();
+		this.eventEmitter = new EventEmitter();
+
+		this.currentProviderType = this.options.logProviderConfig.type;
+		this.initializeLogProvider();
+	}
+
+	private initializeLogProvider(subscribe = false) {
+		const logProviderConfig = this.options.logProviderConfig;
+
+		if (this.currentProviderType === 'websocket') {
+			this.logProvider = new WebSocketLogProvider(
+				// @ts-ignore
+				this.connection,
+				this.address,
+				this.options.commitment,
+				(
+					this.options.logProviderConfig as WebSocketLogProviderConfig
+				).resubTimeoutMs
+			);
+		} else if (this.currentProviderType === 'polling') {
+			const frequency =
+				'frequency' in logProviderConfig
+					? (logProviderConfig as PollingLogProviderConfig).frequency
+					: (logProviderConfig as StreamingLogProviderConfig).fallbackFrequency;
+			const batchSize =
+				'batchSize' in logProviderConfig
+					? (logProviderConfig as PollingLogProviderConfig).batchSize
+					: (logProviderConfig as StreamingLogProviderConfig).fallbackBatchSize;
+
+			this.logProvider = new PollingLogProvider(
+				// @ts-ignore
+				this.connection,
+				this.address,
+				this.options.commitment,
+				frequency,
+				batchSize
+			);
+		} else if (this.currentProviderType === 'events-server') {
+			this.logProvider = new EventsServerLogProvider(
+				(logProviderConfig as EventsServerLogProviderConfig).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
+			);
+		}
+	}
+
+	private populateInitialEventListMap() {
+		for (const eventType of this.options.eventTypes) {
+			this.eventListMap.set(
+				eventType,
+				new EventList(
+					eventType,
+					this.options.maxEventsPerType,
+					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.
+	 */
+	private updateFallbackProviderType(
+		reconnectAttempts: number,
+		maxReconnectAttempts: number
+	) {
+		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;
+	}
+
+	public async subscribe(): Promise<boolean> {
+		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 as StreamingLogProviderConfig;
+
+				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;
+		}
+	}
+
+	private handleTxLogs(
+		txSig: TransactionSignature,
+		slot: number,
+		logs: string[],
+		mostRecentBlockTime: number | undefined,
+		fromEventsServer = false,
+		txSigIndex: number | undefined = undefined
+	): void {
+		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);
+	}
+
+	public async fetchPreviousTx(fetchMax?: boolean): Promise<void> {
+		if (!this.options.untilTx && !fetchMax) {
+			return;
+		}
+
+		let txFetched = 0;
+		let beforeTx: TransactionSignature = undefined;
+		const untilTx: TransactionSignature = this.options.untilTx;
+		while (txFetched < this.options.maxTx) {
+			const response = await 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);
+			}
+		}
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		this.eventListMap.clear();
+		this.txEventCache.clear();
+		this.awaitTxPromises.clear();
+		this.awaitTxResolver.clear();
+
+		return await this.logProvider.unsubscribe(true);
+	}
+
+	private parseEventsFromLogs(
+		txSig: TransactionSignature,
+		slot: number,
+		logs: string[],
+		txSigIndex: number | undefined
+	): WrappedEvents {
+		const records = [];
+		// @ts-ignore
+		const events = 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;
+	}
+
+	public awaitTx(txSig: TransactionSignature): Promise<void> {
+		if (this.awaitTxPromises.has(txSig)) {
+			return this.awaitTxPromises.get(txSig);
+		}
+
+		if (this.txEventCache.has(txSig)) {
+			return Promise.resolve();
+		}
+
+		const promise = new Promise<void>((resolve) => {
+			this.awaitTxResolver.set(txSig, resolve);
+		});
+		this.awaitTxPromises.set(txSig, promise);
+		return promise;
+	}
+
+	public getEventList<Type extends keyof EventMap>(
+		eventType: Type
+	): EventList<Type> {
+		return this.eventListMap.get(eventType) as 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
+	 */
+	public getEventsArray<Type extends EventType>(
+		eventType: Type
+	): EventMap[Type][] {
+		return this.eventListMap.get(eventType).toArray() as EventMap[Type][];
+	}
+
+	public getEventsByTx(txSig: TransactionSignature): WrappedEvents | undefined {
+		return this.txEventCache.get(txSig);
+	}
+}

package/src/events/eventsServerLogProvider.ts

@@ -0,0 +1,152 @@
+// import WebSocket from 'ws';
+import { logProviderCallback, EventType, LogProvider } from './types';
+import { EventEmitter } from 'events';
+
+// browser support
+let WebSocketImpl: typeof WebSocket;
+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;
+
+export class EventsServerLogProvider implements LogProvider {
+	private ws?: WebSocket;
+	private callback?: logProviderCallback;
+	private isUnsubscribing = false;
+	private externalUnsubscribe = false;
+	private lastHeartbeat = 0;
+	private timeoutId?: NodeJS.Timeout;
+	private reconnectAttempts = 0;
+	eventEmitter?: EventEmitter;
+
+	public constructor(
+		private readonly url: string,
+		private readonly eventTypes: EventType[],
+		private readonly userAccount?: string
+	) {
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public isSubscribed(): boolean {
+		return this.ws !== undefined;
+	}
+
+	public async subscribe(callback: logProviderCallback): Promise<boolean> {
+		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;
+	}
+
+	public async unsubscribe(external = false): Promise<boolean> {
+		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;
+		}
+	}
+
+	private setTimeout(): void {
+		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);
+	}
+}