@drift-labs/sdk 2.96.0-beta.0 → 2.96.0-beta.1

package/src/accounts/webSocketAccountSubscriber.ts

@@ -94,7 +94,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		};
 	}
 
-	private setTimeout(): void {
+	protected setTimeout(): void {
 		if (!this.onChange) {
 			throw new Error('onChange callback function must be set');
 		}

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -60,9 +60,9 @@ export class WebSocketDriftClientAccountSubscriber
 	initialSpotMarketAccountData: Map<number, SpotMarketAccount>;
 	initialOraclePriceData: Map<string, OraclePriceData>;
 
-	private isSubscribing = false;
-	private subscriptionPromise: Promise<boolean>;
-	private subscriptionPromiseResolver: (val: boolean) => void;
+	protected isSubscribing = false;
+	protected subscriptionPromise: Promise<boolean>;
+	protected subscriptionPromiseResolver: (val: boolean) => void;
 
 	public constructor(
 		program: Program,

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -98,7 +98,7 @@ export class WebSocketProgramAccountSubscriber<T>
 		}
 	}
 
-	private setTimeout(): void {
+	protected setTimeout(): void {
 		if (!this.onChange) {
 			throw new Error('onChange callback function must be set');
 		}

package/src/driftClient.ts

@@ -152,6 +152,7 @@ import { isVersionedTransaction } from './tx/utils';
 import pythSolanaReceiverIdl from './idl/pyth_solana_receiver.json';
 import { asV0Tx, PullFeed } from '@switchboard-xyz/on-demand';
 import switchboardOnDemandIdl from './idl/switchboard_on_demand_30.json';
+import { gprcDriftClientAccountSubscriber } from './accounts/grpcDriftClientAccountSubscriber';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -292,6 +293,19 @@ export class DriftClient {
 				type: 'polling',
 				accountLoader: config.accountSubscription.accountLoader,
 			};
+		} else if (config.accountSubscription?.type === 'grpc') {
+			this.userAccountSubscriptionConfig = {
+				type: 'grpc',
+				resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+				logResubMessages: config.accountSubscription?.logResubMessages,
+				configs: config.accountSubscription?.configs,
+			};
+			this.userStatsAccountSubscriptionConfig = {
+				type: 'grpc',
+				resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+				logResubMessages: config.accountSubscription?.logResubMessages,
+				configs: config.accountSubscription?.configs,
+			};
 		} else {
 			this.userAccountSubscriptionConfig = {
 				type: 'websocket',
@@ -338,6 +352,19 @@ export class DriftClient {
 				config.oracleInfos ?? [],
 				noMarketsAndOraclesSpecified
 			);
+		} else if (config.accountSubscription?.type === 'grpc') {
+			this.accountSubscriber = new gprcDriftClientAccountSubscriber(
+				config.accountSubscription.configs,
+				this.program,
+				config.perpMarketIndexes ?? [],
+				config.spotMarketIndexes ?? [],
+				config.oracleInfos ?? [],
+				noMarketsAndOraclesSpecified,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				}
+			);
 		} else {
 			this.accountSubscriber = new WebSocketDriftClientAccountSubscriber(
 				this.program,
@@ -352,6 +379,7 @@ export class DriftClient {
 				config.accountSubscription?.commitment
 			);
 		}
+
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
 
 		this.metricsEventEmitter = new EventEmitter();

package/src/driftClientConfig.ts

@@ -11,6 +11,7 @@ import { BulkAccountLoader } from './accounts/bulkAccountLoader';
 import { DriftEnv } from './config';
 import { TxSender } from './tx/types';
 import { TxHandler, TxHandlerConfig } from './tx/txHandler';
+import { GrpcConfigs } from './accounts/types';
 
 export type DriftClientConfig = {
 	connection: Connection;
@@ -48,4 +49,10 @@ export type DriftClientSubscriptionConfig =
 	| {
 			type: 'polling';
 			accountLoader: BulkAccountLoader;
+	  }
+	| {
+			type: 'grpc';
+			configs: GrpcConfigs;
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
 	  };

package/src/orderSubscriber/OrderSubscriber.ts

@@ -11,11 +11,12 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { BN } from '../index';
 import { decodeUser } from '../decode/user';
+import { grpcSubscription } from './grpcSubscription';
 
 export class OrderSubscriber {
 	driftClient: DriftClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
-	subscription: PollingSubscription | WebsocketSubscription;
+	subscription: PollingSubscription | WebsocketSubscription | grpcSubscription;
 	commitment: Commitment;
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
@@ -34,6 +35,19 @@ export class OrderSubscriber {
 				orderSubscriber: this,
 				frequency: config.subscriptionConfig.frequency,
 			});
+		} else if (config.subscriptionConfig.type === 'grpc') {
+			this.subscription = new grpcSubscription({
+				grpcConfigs: config.subscriptionConfig.configs,
+				orderSubscriber: this,
+				commitment: this.commitment,
+				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig?.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig?.logResubMessages,
+				},
+				resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
+				decoded: config.decodeData,
+			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,

package/src/orderSubscriber/grpcSubscription.ts

@@ -0,0 +1,126 @@
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+import { OrderSubscriber } from './OrderSubscriber';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { UserAccount } from '../types';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+
+export class grpcSubscription {
+	private orderSubscriber: OrderSubscriber;
+	private commitment: Commitment;
+	private skipInitialLoad: boolean;
+	private resubOpts?: ResubOpts;
+	private resyncIntervalMs?: number;
+
+	private subscriber?: grpcProgramAccountSubscriber<UserAccount>;
+	private resyncTimeoutId?: NodeJS.Timeout;
+
+	private decoded?: boolean;
+
+	private grpcConfigs: GrpcConfigs;
+
+	constructor({
+		grpcConfigs,
+		orderSubscriber,
+		commitment,
+		skipInitialLoad = false,
+		resubOpts,
+		resyncIntervalMs,
+		decoded = true,
+	}: {
+		grpcConfigs: GrpcConfigs;
+		orderSubscriber: OrderSubscriber;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubOpts?: ResubOpts;
+		resyncIntervalMs?: number;
+		decoded?: boolean;
+	}) {
+		this.orderSubscriber = orderSubscriber;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubOpts = resubOpts;
+		this.resyncIntervalMs = resyncIntervalMs;
+		this.decoded = decoded;
+		this.grpcConfigs = grpcConfigs;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscriber) {
+			return;
+		}
+
+		this.subscriber = new grpcProgramAccountSubscriber<UserAccount>(
+			this.grpcConfigs,
+			'OrderSubscriber',
+			'User',
+			this.orderSubscriber.driftClient.program,
+			this.orderSubscriber.decodeFn,
+			{
+				filters: [getUserFilter(), getNonIdleUserFilter()],
+				commitment: this.commitment,
+			},
+			this.resubOpts
+		);
+
+		await this.subscriber.subscribe(
+			(
+				accountId: PublicKey,
+				account: UserAccount,
+				context: Context,
+				buffer: Buffer
+			) => {
+				const userKey = accountId.toBase58();
+				if (this.decoded ?? true) {
+					this.orderSubscriber.tryUpdateUserAccount(
+						userKey,
+						'decoded',
+						account,
+						context.slot
+					);
+				} else {
+					this.orderSubscriber.tryUpdateUserAccount(
+						userKey,
+						'buffer',
+						buffer,
+						context.slot
+					);
+				}
+			}
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.orderSubscriber.fetch();
+		}
+
+		if (this.resyncIntervalMs) {
+			const recursiveResync = () => {
+				this.resyncTimeoutId = setTimeout(() => {
+					this.orderSubscriber
+						.fetch()
+						.catch((e) => {
+							console.error('Failed to resync in OrderSubscriber');
+							console.log(e);
+						})
+						.finally(() => {
+							// eslint-disable-next-line @typescript-eslint/no-unused-vars
+							if (!this.resyncTimeoutId) return;
+							recursiveResync();
+						});
+				}, this.resyncIntervalMs);
+			};
+			recursiveResync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+		if (this.resyncTimeoutId !== undefined) {
+			clearTimeout(this.resyncTimeoutId);
+			this.resyncTimeoutId = undefined;
+		}
+	}
+}

package/src/orderSubscriber/types.ts

@@ -1,6 +1,7 @@
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { Order, UserAccount } from '../types';
 import { DriftClient } from '../driftClient';
+import { GrpcConfigs } from '../accounts/types';
 
 export type OrderSubscriberConfig = {
 	driftClient: DriftClient;
@@ -10,6 +11,15 @@ export type OrderSubscriberConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
+		| {
+				type: 'grpc';
+				skipInitialLoad?: boolean;
+				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
+				resyncIntervalMs?: number;
+				configs: GrpcConfigs;
+				commitment?: Commitment;
+		  }
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;

package/src/user.ts

@@ -98,6 +98,7 @@ import {
 	calculatePerpFuelBonus,
 	calculateInsuranceFuelBonus,
 } from './math/fuel';
+import { grpcUserAccountSubscriber } from './accounts/grpcUserAccountSubscriber';
 
 export class User {
 	driftClient: DriftClient;
@@ -128,6 +129,16 @@ export class User {
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
+		} else if (config.accountSubscription?.type === 'grpc') {
+			this.accountSubscriber = new grpcUserAccountSubscriber(
+				config.accountSubscription.configs,
+				config.driftClient.program,
+				config.userAccountPublicKey,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				}
+			);
 		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,

package/src/userConfig.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-import { UserAccountSubscriber } from './accounts/types';
+import { GrpcConfigs, UserAccountSubscriber } from './accounts/types';
 
 export type UserConfig = {
 	accountSubscription?: UserSubscriptionConfig;
@@ -23,4 +23,10 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'custom';
 			userAccountSubscriber: UserAccountSubscriber;
+	  }
+	| {
+			type: 'grpc';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			configs: GrpcConfigs;
 	  };

package/src/userMap/grpcSubscription.ts

@@ -0,0 +1,83 @@
+import { UserMap } from './userMap';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+
+export class grpcSubscription {
+	private configs: GrpcConfigs;
+	private userMap: UserMap;
+	private commitment: Commitment;
+	private skipInitialLoad: boolean;
+	private resubOpts?: ResubOpts;
+	private includeIdle?: boolean;
+	private decodeFn: (name: string, data: Buffer) => UserAccount;
+
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+
+	constructor({
+		configs,
+		userMap,
+		commitment,
+		skipInitialLoad = false,
+		resubOpts,
+		includeIdle = false,
+		decodeFn,
+	}: {
+		configs: GrpcConfigs;
+		userMap: UserMap;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubOpts?: ResubOpts;
+		includeIdle?: boolean;
+		decodeFn: (name: string, data: Buffer) => UserAccount;
+	}) {
+		this.userMap = userMap;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubOpts = resubOpts;
+		this.includeIdle = includeIdle || false;
+		this.decodeFn = decodeFn;
+		this.configs = configs;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (!this.subscriber) {
+			const filters = [getUserFilter()];
+			if (!this.includeIdle) {
+				filters.push(getNonIdleUserFilter());
+			}
+			this.subscriber = new grpcProgramAccountSubscriber<UserAccount>(
+				this.configs,
+				'UserMap',
+				'User',
+				this.userMap.driftClient.program,
+				this.decodeFn,
+				{
+					filters,
+					commitment: this.commitment,
+				},
+				this.resubOpts
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, account: UserAccount, context: Context) => {
+				const userKey = accountId.toBase58();
+				this.userMap.updateUserAccount(userKey, account, context.slot);
+			}
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.userMap.sync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+	}
+}

package/src/userMap/userMap.ts

@@ -36,6 +36,7 @@ import {
 import { WebsocketSubscription } from './WebsocketSubscription';
 import { PollingSubscription } from './PollingSubscription';
 import { decodeUser } from '../decode/user';
+import { grpcSubscription } from './grpcSubscription';
 
 const MAX_USER_ACCOUNT_SIZE_BYTES = 4376;
 
@@ -75,7 +76,10 @@ export class UserMap implements UserMapInterface {
 	private includeIdle: boolean;
 	private disableSyncOnTotalAccountsChange: boolean;
 	private lastNumberOfSubAccounts: BN;
-	private subscription: PollingSubscription | WebsocketSubscription;
+	private subscription:
+		| PollingSubscription
+		| WebsocketSubscription
+		| grpcSubscription;
 	private stateAccountUpdateCallback = async (state: StateAccount) => {
 		if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
 			await this.sync();
@@ -122,6 +126,18 @@ export class UserMap implements UserMapInterface {
 				frequency: config.subscriptionConfig.frequency,
 				skipInitialLoad: config.skipInitialLoad,
 			});
+		} else if (config.subscriptionConfig.type === 'grpc') {
+			this.subscription = new grpcSubscription({
+				configs: config.subscriptionConfig.configs,
+				userMap: this,
+				commitment: this.commitment,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig.logResubMessages,
+				},
+				skipInitialLoad: config.skipInitialLoad,
+				decodeFn,
+			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				userMap: this,

package/src/userMap/userMapConfig.ts

@@ -1,5 +1,6 @@
 import { Commitment, Connection } from '@solana/web3.js';
 import { DriftClient } from '../driftClient';
+import { GrpcConfigs } from '../accounts/types';
 
 // passed into UserMap.getUniqueAuthorities to filter users
 export type UserAccountFilterCriteria = {
@@ -27,6 +28,13 @@ export type UserMapConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
+		| {
+				type: 'grpc';
+				configs: GrpcConfigs;
+				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
+				commitment?: Commitment;
+		  }
 		| {
 				type: 'websocket';
 				resubTimeoutMs?: number;

package/src/userStatsConfig.ts

@@ -1,6 +1,7 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { GrpcConfigs } from './accounts/types';
 
 export type UserStatsConfig = {
 	accountSubscription?: UserStatsSubscriptionConfig;
@@ -21,4 +22,10 @@ export type UserStatsSubscriptionConfig =
 	  }
 	| {
 			type: 'custom';
+	  }
+	| {
+			type: 'grpc';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			configs: GrpcConfigs;
 	  };