@drift-labs/sdk 2.40.0-beta.7 → 2.40.0-beta.9

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -0,0 +1,152 @@
+import { DataAndSlot, BufferAndSlot, ProgramAccountSubscriber } from './types';
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import {
+	Commitment,
+	Context,
+	KeyedAccountInfo,
+	MemcmpFilter,
+	PublicKey,
+} from '@solana/web3.js';
+import * as Buffer from 'buffer';
+
+export class WebSocketProgramAccountSubscriber<T>
+	implements ProgramAccountSubscriber<T>
+{
+	subscriptionName: string;
+	accountDiscriminator: string;
+	dataAndSlot?: DataAndSlot<T> & { accountId: PublicKey };
+	bufferAndSlot?: BufferAndSlot;
+	program: Program;
+	decodeBuffer: (accountName: string, ix: Buffer) => T;
+	onChange: (accountId: PublicKey, data: T, context: Context) => void;
+	listenerId?: number;
+	resubTimeoutMs?: number;
+	timeoutId?: NodeJS.Timeout;
+	options: { filters: MemcmpFilter[]; commitment?: Commitment };
+
+	receivingData = false;
+
+	public constructor(
+		subscriptionName: string,
+		accountDiscriminator: string,
+		program: Program,
+		decodeBufferFn: (accountName: string, ix: Buffer) => T,
+		options: { filters: MemcmpFilter[]; commitment?: Commitment } = {
+			filters: [],
+		},
+		resubTimeoutMs?: number
+	) {
+		this.subscriptionName = subscriptionName;
+		this.accountDiscriminator = accountDiscriminator;
+		this.program = program;
+		this.decodeBuffer = decodeBufferFn;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.options = options;
+		this.receivingData = false;
+	}
+
+	async subscribe(
+		onChange: (accountId: PublicKey, data: T, context: Context) => void
+	): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
+		this.onChange = onChange;
+
+		this.listenerId = this.program.provider.connection.onProgramAccountChange(
+			this.program.programId,
+			(keyedAccountInfo, context) => {
+				if (this.resubTimeoutMs) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.handleRpcResponse(context, keyedAccountInfo);
+					this.setTimeout();
+				} else {
+					this.handleRpcResponse(context, keyedAccountInfo);
+				}
+			},
+			this.options.commitment ??
+				(this.program.provider as AnchorProvider).opts.commitment,
+			this.options.filters
+		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(async () => {
+			if (this.receivingData) {
+				console.log(
+					`No ws data from ${this.subscriptionName} in ${this.resubTimeoutMs}ms, resubscribing`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				await this.subscribe(this.onChange);
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	handleRpcResponse(
+		context: Context,
+		keyedAccountInfo: KeyedAccountInfo
+	): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (keyedAccountInfo) {
+			newBuffer = keyedAccountInfo.accountInfo.data;
+		}
+
+		if (!this.bufferAndSlot) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+				this.dataAndSlot = {
+					data: account,
+					slot: newSlot,
+					accountId: keyedAccountInfo.accountId,
+				};
+				this.onChange(keyedAccountInfo.accountId, account, context);
+			}
+			return;
+		}
+
+		if (newSlot <= this.bufferAndSlot.slot) {
+			return;
+		}
+
+		const oldBuffer = this.bufferAndSlot.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+			this.dataAndSlot = {
+				data: account,
+				slot: newSlot,
+				accountId: keyedAccountInfo.accountId,
+			};
+			this.onChange(keyedAccountInfo.accountId, account, context);
+		}
+	}
+
+	unsubscribe(): Promise<void> {
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
+	}
+}

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -14,17 +14,23 @@ import { UserAccount } from '../types';
 
 export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 	userAccountPublicKey: PublicKey;
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 
-	public constructor(program: Program, userAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userAccountPublicKey = userAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userAccount?: UserAccount): Promise<boolean> {
@@ -35,7 +41,9 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 		this.userDataAccountSubscriber = new WebSocketAccountSubscriber(
 			'user',
 			this.program,
-			this.userAccountPublicKey
+			this.userAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userAccount) {

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -16,17 +16,23 @@ export class WebSocketUserStatsAccountSubscriber
 	implements UserStatsAccountSubscriber
 {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
 	userStatsAccountPublicKey: PublicKey;
 
 	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
 
-	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean> {
@@ -37,7 +43,9 @@ export class WebSocketUserStatsAccountSubscriber
 		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
 			'userStats',
 			this.program,
-			this.userStatsAccountPublicKey
+			this.userStatsAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userStatsAccount) {

package/src/auctionSubscriber/auctionSubscriber.ts

@@ -4,48 +4,57 @@ import { getUserFilter, getUserWithAuctionFilter } from '../memcmp';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
-import { ConfirmOptions } from '@solana/web3.js';
+import { ConfirmOptions, Context, PublicKey } from '@solana/web3.js';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 
 export class AuctionSubscriber {
 	private driftClient: DriftClient;
 	private opts: ConfirmOptions;
+	private resubTimeoutMs?: number;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
-	private websocketId: number;
-
-	constructor({ driftClient, opts }: AuctionSubscriberConfig) {
+	constructor({ driftClient, opts, resubTimeoutMs }: AuctionSubscriberConfig) {
 		this.driftClient = driftClient;
 		this.opts = opts || this.driftClient.opts;
 		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe() {
-		this.websocketId = this.driftClient.connection.onProgramAccountChange(
-			this.driftClient.program.programId,
-			(keyAccountInfo, context) => {
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						keyAccountInfo.accountInfo.data
-					) as UserAccount;
+		if (!this.subscriber) {
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'AuctionSubscriber',
+				'User',
+				this.driftClient.program,
+				this.driftClient.program.account.user.coder.accounts.decode.bind(
+					this.driftClient.program.account.user.coder.accounts
+				),
+				{
+					filters: [getUserFilter(), getUserWithAuctionFilter()],
+					commitment: this.driftClient.opts.commitment,
+				},
+				this.resubTimeoutMs
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, data: UserAccount, context: Context) => {
 				this.eventEmitter.emit(
 					'onAccountUpdate',
-					userAccount,
-					keyAccountInfo.accountId,
+					data,
+					accountId,
 					context.slot
 				);
-			},
-			this.driftClient.opts.commitment,
-			[getUserFilter(), getUserWithAuctionFilter()]
+			}
 		);
 	}
 
 	public async unsubscribe() {
-		if (this.websocketId) {
-			await this.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
+		if (!this.subscriber) {
+			return;
 		}
+		this.subscriber.unsubscribe();
 	}
 }

package/src/auctionSubscriber/types.ts

@@ -5,6 +5,7 @@ import { ConfirmOptions, PublicKey } from '@solana/web3.js';
 export type AuctionSubscriberConfig = {
 	driftClient: DriftClient;
 	opts?: ConfirmOptions;
+	resubTimeoutMs?: number;
 };
 
 export interface AuctionSubscriberEvents {

package/src/constants/spotMarkets.ts

@@ -128,7 +128,7 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		serumMarket: new PublicKey('B2na8Awyd7cpC59iEU43FagJAPLigr3AP3s38KM982bu'),
 	},
 	{
-		symbol: 'jitoSOL',
+		symbol: 'JitoSOL',
 		marketIndex: 6,
 		oracle: new PublicKey('7yyaeuJ1GGtVBLT2z2xub5ZWYKaNhF28mj1RdV4VDFVk'),
 		oracleSource: OracleSource.PYTH,

package/src/driftClient.ts

@@ -278,7 +278,8 @@ export class DriftClient {
 				config.perpMarketIndexes ?? [],
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
-				noMarketsAndOraclesSpecified
+				noMarketsAndOraclesSpecified,
+				config.accountSubscription?.resubTimeoutMs
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;

package/src/driftClientConfig.ts

@@ -36,6 +36,7 @@ export type DriftClientConfig = {
 export type DriftClientSubscriptionConfig =
 	| {
 			type: 'websocket';
+			resubTimeoutMs?: number;
 	  }
 	| {
 			type: 'polling';