@drift-labs/sdk 2.48.0-beta.2 → 2.48.0-beta.20

package/src/events/webSocketLogProvider.ts

@@ -3,10 +3,15 @@ import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 
 export class WebSocketLogProvider implements LogProvider {
 	private subscriptionId: number;
+	private isUnsubscribing = false;
+	private receivingData = false;
+	private timeoutId?: NodeJS.Timeout;
+	private callback?: logProviderCallback;
 	public constructor(
 		private connection: Connection,
 		private address: PublicKey,
-		private commitment: Commitment
+		private commitment: Commitment,
+		private resubTimeoutMs?: number
 	) {}
 
 	public subscribe(callback: logProviderCallback): boolean {
@@ -14,13 +19,24 @@ export class WebSocketLogProvider implements LogProvider {
 			return true;
 		}
 
+		this.callback = callback;
 		this.subscriptionId = this.connection.onLogs(
 			this.address,
 			(logs, ctx) => {
+				if (this.resubTimeoutMs && !this.isUnsubscribing) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+				}
 				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},
 			this.commitment
 		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+
 		return true;
 	}
 
@@ -29,10 +45,41 @@ export class WebSocketLogProvider implements LogProvider {
 	}
 
 	public async unsubscribe(): Promise<boolean> {
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+
 		if (this.subscriptionId !== undefined) {
-			await this.connection.removeOnLogsListener(this.subscriptionId);
-			this.subscriptionId = undefined;
+			this.connection
+				.removeOnLogsListener(this.subscriptionId)
+				.then(() => {
+					this.subscriptionId = undefined;
+					this.isUnsubscribing = false;
+					return true;
+				})
+				.catch((err) => {
+					console.log('Error unsubscribing from logs: ', err);
+					this.isUnsubscribing = false;
+					return false;
+				});
+		} else {
+			this.isUnsubscribing = false;
+			return true;
 		}
-		return true;
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(`No log data in ${this.resubTimeoutMs}ms, resubscribing`);
+				await this.unsubscribe();
+				this.receivingData = false;
+				this.subscribe(this.callback);
+			}
+		}, this.resubTimeoutMs);
 	}
 }

package/src/orderSubscriber/OrderSubscriber.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from '../driftClient';
 import { UserAccount } from '../types';
 import { getUserFilter, getUserWithOrderFilter } from '../memcmp';
-import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import { Commitment, PublicKey, RpcResponseAndContext } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { DLOB } from '../dlob/DLOB';
 import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
@@ -14,13 +14,17 @@ export class OrderSubscriber {
 	driftClient: DriftClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
 	subscription: PollingSubscription | WebsocketSubscription;
+	commitment: Commitment;
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
 	fetchPromise?: Promise<void>;
 	fetchPromiseResolver: () => void;
 
+	mostRecentSlot: number;
+
 	constructor(config: OrderSubscriberConfig) {
 		this.driftClient = config.driftClient;
+		this.commitment = config.subscriptionConfig.commitment || 'processed';
 		if (config.subscriptionConfig.type === 'polling') {
 			this.subscription = new PollingSubscription({
 				orderSubscriber: this,
@@ -29,6 +33,7 @@ export class OrderSubscriber {
 		} else {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,
+				commitment: this.commitment,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
@@ -53,7 +58,7 @@ export class OrderSubscriber {
 			const rpcRequestArgs = [
 				this.driftClient.program.programId.toBase58(),
 				{
-					commitment: this.driftClient.opts.commitment,
+					commitment: this.commitment,
 					filters: [getUserFilter(), getUserWithOrderFilter()],
 					encoding: 'base64',
 					withContext: true,
@@ -81,18 +86,13 @@ export class OrderSubscriber {
 			const programAccountSet = new Set<string>();
 			for (const programAccount of rpcResponseAndContext.value) {
 				const key = programAccount.pubkey.toString();
-				// @ts-ignore
-				const buffer = Buffer.from(
-					programAccount.account.data[0],
-					programAccount.account.data[1]
-				);
 				programAccountSet.add(key);
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						buffer
-					) as UserAccount;
-				this.tryUpdateUserAccount(key, userAccount, slot);
+				this.tryUpdateUserAccount(
+					key,
+					'raw',
+					programAccount.account.data,
+					slot
+				);
 			}
 
 			for (const key of this.usersAccounts.keys()) {
@@ -110,11 +110,31 @@ export class OrderSubscriber {
 
 	tryUpdateUserAccount(
 		key: string,
-		userAccount: UserAccount,
+		dataType: 'raw' | 'decoded',
+		data: string[] | UserAccount,
 		slot: number
 	): void {
+		if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
+			this.mostRecentSlot = slot;
+		}
+
 		const slotAndUserAccount = this.usersAccounts.get(key);
-		if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
+		if (!slotAndUserAccount || slotAndUserAccount.slot <= slot) {
+			let userAccount: UserAccount;
+			// Polling leads to a lot of redundant decoding, so we only decode if data is from a fresh slot
+			if (dataType === 'raw') {
+				// @ts-ignore
+				const buffer = Buffer.from(data[0], data[1]);
+
+				userAccount =
+					this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
+						'User',
+						buffer
+					) as UserAccount;
+			} else {
+				userAccount = data as UserAccount;
+			}
+
 			const newOrders = userAccount.orders.filter(
 				(order) =>
 					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&
@@ -148,6 +168,10 @@ export class OrderSubscriber {
 		return dlob;
 	}
 
+	public getSlot(): number {
+		return this.mostRecentSlot ?? 0;
+	}
+
 	public async unsubscribe(): Promise<void> {
 		await this.subscription.unsubscribe();
 	}

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -2,10 +2,11 @@ import { OrderSubscriber } from './OrderSubscriber';
 import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
 import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 import { UserAccount } from '../types';
-import { Context, PublicKey } from '@solana/web3.js';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
 
 export class WebsocketSubscription {
 	private orderSubscriber: OrderSubscriber;
+	private commitment: Commitment;
 	private skipInitialLoad: boolean;
 	private resubTimeoutMs?: number;
 
@@ -13,14 +14,17 @@ export class WebsocketSubscription {
 
 	constructor({
 		orderSubscriber,
+		commitment,
 		skipInitialLoad = false,
 		resubTimeoutMs,
 	}: {
 		orderSubscriber: OrderSubscriber;
+		commitment: Commitment;
 		skipInitialLoad?: boolean;
 		resubTimeoutMs?: number;
 	}) {
 		this.orderSubscriber = orderSubscriber;
+		this.commitment = commitment;
 		this.skipInitialLoad = skipInitialLoad;
 		this.resubTimeoutMs = resubTimeoutMs;
 	}
@@ -36,7 +40,7 @@ export class WebsocketSubscription {
 				),
 				{
 					filters: [getUserFilter(), getNonIdleUserFilter()],
-					commitment: this.orderSubscriber.driftClient.opts.commitment,
+					commitment: this.commitment,
 				},
 				this.resubTimeoutMs
 			);
@@ -47,6 +51,7 @@ export class WebsocketSubscription {
 				const userKey = accountId.toBase58();
 				this.orderSubscriber.tryUpdateUserAccount(
 					userKey,
+					'decoded',
 					account,
 					context.slot
 				);

package/src/orderSubscriber/types.ts

@@ -1,4 +1,4 @@
-import { PublicKey } from '@solana/web3.js';
+import { Commitment, PublicKey } from '@solana/web3.js';
 import { Order, UserAccount } from '../types';
 import { DriftClient } from '../driftClient';
 
@@ -8,11 +8,13 @@ export type OrderSubscriberConfig = {
 		| {
 				type: 'polling';
 				frequency: number;
+				commitment?: Commitment;
 		  }
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;
 				resubTimeoutMs?: number;
+				commitment?: Commitment;
 		  };
 };
 

package/src/slot/SlotSubscriber.ts

@@ -29,8 +29,10 @@ export class SlotSubscriber {
 		this.currentSlot = await this.connection.getSlot('confirmed');
 
 		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
-			this.currentSlot = slotInfo.slot;
-			this.eventEmitter.emit('newSlot', slotInfo.slot);
+			if (!this.currentSlot || this.currentSlot < slotInfo.slot) {
+				this.currentSlot = slotInfo.slot;
+				this.eventEmitter.emit('newSlot', slotInfo.slot);
+			}
 		});
 	}
 

package/src/user.ts

@@ -109,12 +109,12 @@ export class User {
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
-		} else if (config.accountSubscription?.type === 'websocket') {
+		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
 				config.userAccountPublicKey,
-				config.accountSubscription.resubTimeoutMs,
-				config.accountSubscription.commitment
+				config.accountSubscription?.resubTimeoutMs,
+				config.accountSubscription?.commitment
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;

package/src/userMap/userMap.ts

@@ -32,33 +32,59 @@ export interface UserMapInterface {
 	values(): IterableIterator<User>;
 }
 
+// filter users that meet these criteria when passing into syncCallback
+export type SyncCallbackCriteria = {
+	// only sync users that have open orders
+	hasOpenOrders: boolean;
+};
+
 export class UserMap implements UserMapInterface {
 	private userMap = new Map<string, User>();
 	private driftClient: DriftClient;
 	private accountSubscription: UserSubscriptionConfig;
 	private includeIdle: boolean;
 	private lastNumberOfSubAccounts;
-	private syncCallback = async (state: StateAccount) => {
+	private stateAccountUpdateCallback = async (state: StateAccount) => {
 		if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
 			await this.sync();
 			this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
 		}
 	};
+	private syncCallback: (authorities: PublicKey[]) => Promise<void>;
+	private syncCallbackCriteria: SyncCallbackCriteria;
+
+	private syncPromise?: Promise<void>;
+	private syncPromiseResolver: () => void;
 
 	/**
+	 * Constructs a new UserMap instance.
 	 *
-	 * @param driftClient
-	 * @param accountSubscription
-	 * @param includeIdle whether idle users are subscribed to. defaults to false to decrease # of user subscriptions
+	 * @param {DriftClient} driftClient - The DriftClient instance.
+	 * @param {UserSubscriptionConfig} accountSubscription - The UserSubscriptionConfig instance.
+	 * @param {boolean} includeIdle - Whether idle users are subscribed to. Defaults to false to decrease # of user subscriptions.
+	 * @param {(authorities: PublicKey[]) => Promise<void>} syncCallback - Called after `sync` completes, will pas in unique list of authorities. Useful for using it to sync UserStatsMap.
+	 * @param {SyncCallbackCriteria} syncCallbackCriteria - The criteria for the sync callback. Defaults to having no filters
 	 */
 	constructor(
 		driftClient: DriftClient,
 		accountSubscription: UserSubscriptionConfig,
-		includeIdle = false
+		includeIdle = false,
+		syncCallback?: (authorities: PublicKey[]) => Promise<void>,
+		syncCallbackCriteria: SyncCallbackCriteria = { hasOpenOrders: false }
 	) {
 		this.driftClient = driftClient;
 		this.accountSubscription = accountSubscription;
 		this.includeIdle = includeIdle;
+		this.syncCallback = syncCallback;
+		this.syncCallbackCriteria = syncCallbackCriteria;
+	}
+
+	public addSyncCallback(
+		syncCallback?: (authorities: PublicKey[]) => Promise<void>,
+		syncCallbackCriteria: SyncCallbackCriteria = { hasOpenOrders: false }
+	) {
+		this.syncCallback = syncCallback;
+		this.syncCallbackCriteria = syncCallbackCriteria;
 	}
 
 	public async subscribe() {
@@ -69,7 +95,10 @@ export class UserMap implements UserMapInterface {
 		await this.driftClient.subscribe();
 		this.lastNumberOfSubAccounts =
 			this.driftClient.getStateAccount().numberOfSubAccounts;
-		this.driftClient.eventEmitter.on('stateAccountUpdate', this.syncCallback);
+		this.driftClient.eventEmitter.on(
+			'stateAccountUpdate',
+			this.stateAccountUpdateCallback
+		);
 
 		await this.sync();
 	}
@@ -187,74 +216,118 @@ export class UserMap implements UserMapInterface {
 		return this.userMap.size;
 	}
 
+	public getUniqueAuthorities(useSyncCallbackCriteria = true): PublicKey[] {
+		const usersMeetingCriteria = Array.from(this.userMap.values()).filter(
+			(user) => {
+				let pass = true;
+				if (
+					useSyncCallbackCriteria &&
+					this.syncCallbackCriteria.hasOpenOrders
+				) {
+					pass = pass && user.getUserAccount().hasOpenOrder;
+				}
+				return pass;
+			}
+		);
+		const userAuths = new Set(
+			usersMeetingCriteria.map((user) =>
+				user.getUserAccount().authority.toBase58()
+			)
+		);
+		const userAuthKeys = Array.from(userAuths).map(
+			(userAuth) => new PublicKey(userAuth)
+		);
+		return userAuthKeys;
+	}
+
 	public async sync() {
-		const filters = [getUserFilter()];
-		if (!this.includeIdle) {
-			filters.push(getNonIdleUserFilter());
+		if (this.syncPromise) {
+			return this.syncPromise;
 		}
+		this.syncPromise = new Promise((resolver) => {
+			this.syncPromiseResolver = resolver;
+		});
 
-		const rpcRequestArgs = [
-			this.driftClient.program.programId.toBase58(),
-			{
-				commitment: this.driftClient.connection.commitment,
-				filters,
-				encoding: 'base64',
-				withContext: true,
-			},
-		];
-
-		// @ts-ignore
-		const rpcJSONResponse: any = await this.driftClient.connection._rpcRequest(
-			'getProgramAccounts',
-			rpcRequestArgs
-		);
+		try {
+			const filters = [getUserFilter()];
+			if (!this.includeIdle) {
+				filters.push(getNonIdleUserFilter());
+			}
 
-		const rpcResponseAndContext: RpcResponseAndContext<
-			Array<{
-				pubkey: PublicKey;
-				account: {
-					data: [string, string];
-				};
-			}>
-		> = rpcJSONResponse.result;
-
-		const slot = rpcResponseAndContext.context.slot;
-
-		const programAccountBufferMap = new Map<string, Buffer>();
-		for (const programAccount of rpcResponseAndContext.value) {
-			programAccountBufferMap.set(
-				programAccount.pubkey.toString(),
+			const rpcRequestArgs = [
+				this.driftClient.program.programId.toBase58(),
+				{
+					commitment: this.driftClient.connection.commitment,
+					filters,
+					encoding: 'base64',
+					withContext: true,
+				},
+			];
+
+			const rpcJSONResponse: any =
 				// @ts-ignore
-				Buffer.from(
-					programAccount.account.data[0],
-					programAccount.account.data[1]
-				)
-			);
-		}
+				await this.driftClient.connection._rpcRequest(
+					'getProgramAccounts',
+					rpcRequestArgs
+				);
+
+			const rpcResponseAndContext: RpcResponseAndContext<
+				Array<{
+					pubkey: PublicKey;
+					account: {
+						data: [string, string];
+					};
+				}>
+			> = rpcJSONResponse.result;
+
+			const slot = rpcResponseAndContext.context.slot;
 
-		for (const [key, buffer] of programAccountBufferMap.entries()) {
-			if (!this.has(key)) {
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						buffer
-					);
-				await this.addPubkey(new PublicKey(key), userAccount);
+			const programAccountBufferMap = new Map<string, Buffer>();
+			for (const programAccount of rpcResponseAndContext.value) {
+				programAccountBufferMap.set(
+					programAccount.pubkey.toString(),
+					// @ts-ignore
+					Buffer.from(
+						programAccount.account.data[0],
+						programAccount.account.data[1]
+					)
+				);
 			}
-		}
 
-		for (const [key, user] of this.userMap.entries()) {
-			if (!programAccountBufferMap.has(key)) {
-				await user.unsubscribe();
-				this.userMap.delete(key);
-			} else {
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						programAccountBufferMap.get(key)
-					);
-				user.accountSubscriber.updateData(userAccount, slot);
+			for (const [key, buffer] of programAccountBufferMap.entries()) {
+				if (!this.has(key)) {
+					const userAccount =
+						this.driftClient.program.account.user.coder.accounts.decode(
+							'User',
+							buffer
+						);
+					await this.addPubkey(new PublicKey(key), userAccount);
+				}
+			}
+
+			for (const [key, user] of this.userMap.entries()) {
+				if (!programAccountBufferMap.has(key)) {
+					await user.unsubscribe();
+					this.userMap.delete(key);
+				} else {
+					const userAccount =
+						this.driftClient.program.account.user.coder.accounts.decode(
+							'User',
+							programAccountBufferMap.get(key)
+						);
+					user.accountSubscriber.updateData(userAccount, slot);
+				}
+			}
+
+			if (this.syncCallback) {
+				await this.syncCallback(this.getUniqueAuthorities());
 			}
+		} catch (e) {
+			console.error(`Error in UserMap.sync()`);
+			console.error(e);
+		} finally {
+			this.syncPromiseResolver();
+			this.syncPromise = undefined;
 		}
 	}
 
@@ -267,7 +340,7 @@ export class UserMap implements UserMapInterface {
 		if (this.lastNumberOfSubAccounts) {
 			this.driftClient.eventEmitter.removeListener(
 				'stateAccountUpdate',
-				this.syncCallback
+				this.stateAccountUpdateCallback
 			);
 			this.lastNumberOfSubAccounts = undefined;
 		}