@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.0

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,18 @@ export class OrderSubscriber {
 				orderSubscriber: this,
 				frequency: config.subscriptionConfig.frequency,
 			});
+		} else if (config.subscriptionConfig.type === 'grpc') {
+			this.subscription = new grpcSubscription({
+				orderSubscriber: this,
+				grpcConfigs: config.subscriptionConfig.grpcConfigs,
+				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,
@@ -100,10 +113,8 @@ export class OrderSubscriber {
 
 			const slot: number = rpcResponseAndContext.context.slot;
 
-			const programAccountSet = new Set<string>();
 			for (const programAccount of rpcResponseAndContext.value) {
 				const key = programAccount.pubkey.toString();
-				programAccountSet.add(key);
 				this.tryUpdateUserAccount(
 					key,
 					'raw',
@@ -113,14 +124,6 @@ export class OrderSubscriber {
 				// give event loop a chance to breathe
 				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
-
-			for (const key of this.usersAccounts.keys()) {
-				if (!programAccountSet.has(key)) {
-					this.usersAccounts.delete(key);
-				}
-				// give event loop a chance to breathe
-				await new Promise((resolve) => setTimeout(resolve, 0));
-			}
 		} catch (e) {
 			console.error(e);
 		} finally {

package/src/orderSubscriber/grpcSubscription.ts

@@ -0,0 +1,121 @@
+import { 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 { getUserFilter, getNonIdleUserFilter } from '../memcmp';
+
+export class grpcSubscription {
+	private orderSubscriber: OrderSubscriber;
+	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,
+		skipInitialLoad = false,
+		resubOpts,
+		resyncIntervalMs,
+		decoded = true,
+	}: {
+		grpcConfigs: GrpcConfigs;
+		orderSubscriber: OrderSubscriber;
+		skipInitialLoad?: boolean;
+		resubOpts?: ResubOpts;
+		resyncIntervalMs?: number;
+		decoded?: boolean;
+	}) {
+		this.orderSubscriber = orderSubscriber;
+		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()],
+			},
+			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;
@@ -17,6 +18,15 @@ export type OrderSubscriberConfig = {
 				logResubMessages?: boolean;
 				resyncIntervalMs?: number;
 				commitment?: Commitment;
+		  }
+		| {
+				type: 'grpc';
+				grpcConfigs: GrpcConfigs;
+				skipInitialLoad?: boolean;
+				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
+				resyncIntervalMs?: number;
+				commitment?: Commitment;
 		  };
 	fastDecode?: boolean;
 	decodeData?: boolean;

package/src/tx/baseTxSender.ts

@@ -43,6 +43,7 @@ export abstract class BaseTxSender implements TxSender {
 	additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
 	txHandler: TxHandler;
 	trackTxLandRate?: boolean;
+	throwOnTimeoutError: boolean;
 
 	// For landing rate calcs
 	lookbackWindowMinutes: number;
@@ -63,6 +64,7 @@ export abstract class BaseTxSender implements TxSender {
 		txHandler,
 		txLandRateLookbackWindowMinutes = DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES,
 		landRateToFeeFunc,
+		throwOnTimeoutError = true,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -75,6 +77,7 @@ export abstract class BaseTxSender implements TxSender {
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
 		landRateToFeeFunc?: (landRate: number) => number;
+		throwOnTimeoutError?: boolean;
 	}) {
 		this.connection = connection;
 		this.wallet = wallet;
@@ -100,6 +103,7 @@ export abstract class BaseTxSender implements TxSender {
 		}
 		this.landRateToFeeFunc =
 			landRateToFeeFunc ?? this.defaultLandRateToFeeFunc.bind(this);
+		this.throwOnTimeoutError = throwOnTimeoutError;
 	}
 
 	async send(
@@ -283,12 +287,14 @@ export abstract class BaseTxSender implements TxSender {
 			}
 			this.timeoutCount += 1;
 			const duration = (Date.now() - start) / 1000;
-			throw new TxSendError(
-				`Transaction was not confirmed in ${duration.toFixed(
-					2
-				)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
-				NOT_CONFIRMED_ERROR_CODE
-			);
+			if (this.throwOnTimeoutError) {
+				throw new TxSendError(
+					`Transaction was not confirmed in ${duration.toFixed(
+						2
+					)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+					NOT_CONFIRMED_ERROR_CODE
+				);
+			}
 		}
 
 		return response;
@@ -326,12 +332,14 @@ export abstract class BaseTxSender implements TxSender {
 		// Transaction not confirmed within 30 seconds
 		this.timeoutCount += 1;
 		const duration = (Date.now() - start) / 1000;
-		throw new TxSendError(
-			`Transaction was not confirmed in ${duration.toFixed(
-				2
-			)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
-			NOT_CONFIRMED_ERROR_CODE
-		);
+		if (this.throwOnTimeoutError) {
+			throw new TxSendError(
+				`Transaction was not confirmed in ${duration.toFixed(
+					2
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+				NOT_CONFIRMED_ERROR_CODE
+			);
+		}
 	}
 
 	async confirmTransaction(
@@ -407,7 +415,7 @@ export abstract class BaseTxSender implements TxSender {
 		txSig: string,
 		result: SignatureResult
 	): Promise<void> {
-		if (result.err) {
+		if (result?.err) {
 			await throwTransactionError(
 				txSig,
 				this.connection,

package/src/tx/fastSingleTxSender.ts

@@ -43,6 +43,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		txHandler,
 		txLandRateLookbackWindowMinutes,
 		landRateToFeeFunc,
+		throwOnTimeoutError = true,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -58,6 +59,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		txHandler?: TxHandler;
 		txLandRateLookbackWindowMinutes?: number;
 		landRateToFeeFunc?: (landRate: number) => number;
+		throwOnTimeoutError?: boolean;
 	}) {
 		super({
 			connection,
@@ -70,6 +72,7 @@ export class FastSingleTxSender extends BaseTxSender {
 			trackTxLandRate,
 			txLandRateLookbackWindowMinutes,
 			landRateToFeeFunc,
+			throwOnTimeoutError,
 		});
 		this.connection = connection;
 		this.wallet = wallet;
@@ -118,15 +121,15 @@ export class FastSingleTxSender extends BaseTxSender {
 					this.confirmTransaction(txid, opts.commitment).then(
 						async (result) => {
 							this.txSigCache?.set(txid, true);
-							await this.checkConfirmationResultForError(txid, result.value);
+							await this.checkConfirmationResultForError(txid, result?.value);
 							slot = result.context.slot;
 						}
 					);
 				} else {
 					const result = await this.confirmTransaction(txid, opts.commitment);
 					this.txSigCache?.set(txid, true);
-					await this.checkConfirmationResultForError(txid, result.value);
-					slot = result.context.slot;
+					await this.checkConfirmationResultForError(txid, result?.value);
+					slot = result?.context?.slot;
 				}
 			} catch (e) {
 				console.error(e);

package/src/tx/forwardOnlyTxSender.ts

@@ -38,6 +38,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 		trackTxLandRate,
 		txLandRateLookbackWindowMinutes,
 		landRateToFeeFunc,
+		throwOnTimeoutError = true,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -50,6 +51,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
 		landRateToFeeFunc?: (landRate: number) => number;
+		throwOnTimeoutError?: boolean;
 	}) {
 		super({
 			connection,
@@ -63,6 +65,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 			trackTxLandRate,
 			txLandRateLookbackWindowMinutes,
 			landRateToFeeFunc,
+			throwOnTimeoutError,
 		});
 		this.connection = connection;
 		this.wallet = wallet;
@@ -128,7 +131,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 				encodedTxSig,
 				opts.commitment
 			);
-			slot = result.context.slot;
+			slot = result?.context?.slot;
 			this.txSigCache?.set(encodedTxSig, true);
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {

package/src/tx/retryTxSender.ts

@@ -34,6 +34,7 @@ export class RetryTxSender extends BaseTxSender {
 		trackTxLandRate,
 		txLandRateLookbackWindowMinutes,
 		landRateToFeeFunc,
+		throwOnTimeoutError = true,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -47,6 +48,7 @@ export class RetryTxSender extends BaseTxSender {
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
 		landRateToFeeFunc?: (landRate: number) => number;
+		throwOnTimeoutError?: boolean;
 	}) {
 		super({
 			connection,
@@ -60,6 +62,7 @@ export class RetryTxSender extends BaseTxSender {
 			trackTxLandRate,
 			txLandRateLookbackWindowMinutes,
 			landRateToFeeFunc,
+			throwOnTimeoutError,
 		});
 		this.connection = connection;
 		this.wallet = wallet;
@@ -117,9 +120,9 @@ export class RetryTxSender extends BaseTxSender {
 			const result = await this.confirmTransaction(txid, opts.commitment);
 			this.txSigCache?.set(txid, true);
 
-			await this.checkConfirmationResultForError(txid, result.value);
+			await this.checkConfirmationResultForError(txid, result?.value);
 
-			slot = result.context.slot;
+			slot = result?.context?.slot;
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {
 			throw e;

package/src/tx/whileValidTxSender.ts

@@ -68,6 +68,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		trackTxLandRate,
 		txLandRateLookbackWindowMinutes,
 		landRateToFeeFunc,
+		throwOnTimeoutError = true,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -80,6 +81,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
 		landRateToFeeFunc?: (landRate: number) => number;
+		throwOnTimeoutError?: boolean;
 	}) {
 		super({
 			connection,
@@ -92,6 +94,7 @@ export class WhileValidTxSender extends BaseTxSender {
 			txLandRateLookbackWindowMinutes,
 			confirmationStrategy,
 			landRateToFeeFunc,
+			throwOnTimeoutError,
 		});
 		this.retrySleep = retrySleep;
 
@@ -235,7 +238,7 @@ export class WhileValidTxSender extends BaseTxSender {
 
 			this.txSigCache?.set(txid, true);
 
-			await this.checkConfirmationResultForError(txid, result.value);
+			await this.checkConfirmationResultForError(txid, result?.value);
 
 			if (result?.value?.err) {
 				// Fallback error handling if there's a problem reporting the error in checkConfirmationResultForError
@@ -246,7 +249,7 @@ export class WhileValidTxSender extends BaseTxSender {
 				});
 			}
 
-			slot = result.context.slot;
+			slot = result?.context?.slot;
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {
 			throw e;

package/src/types.ts

@@ -914,7 +914,7 @@ export type UserStatsAccount = {
 		current_epoch_referrer_reward: BN;
 	};
 	referrer: PublicKey;
-	isReferrer: boolean;
+	referrerStatus: boolean;
 	authority: PublicKey;
 	ifStakedQuoteAssetAmount: BN;
 
@@ -1083,6 +1083,29 @@ export type SwiftTriggerOrderParams = {
 	baseAssetAmount: BN;
 };
 
+export type RFQMakerOrderParams = {
+	uuid: Uint8Array; // From buffer of standard UUID string
+	authority: PublicKey;
+	subAccountId: number;
+	marketIndex: number;
+	marketType: MarketType;
+	baseAssetAmount: BN;
+	price: BN;
+	direction: PositionDirection;
+	maxTs: BN;
+};
+
+export type RFQMakerMessage = {
+	orderParams: RFQMakerOrderParams;
+	signature: Uint8Array;
+};
+
+export type RFQMatch = {
+	baseAssetAmount: BN;
+	makerOrderParams: RFQMakerOrderParams;
+	makerSignature: Uint8Array;
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	makerStats: PublicKey;
@@ -1102,6 +1125,11 @@ export type ReferrerInfo = {
 	referrerStats: PublicKey;
 };
 
+export enum ReferrerStatus {
+	IsReferrer = 1,
+	IsReferred = 2,
+}
+
 export enum PlaceAndTakeOrderSuccessCondition {
 	PartialFill = 1,
 	FullFill = 2,
@@ -1310,3 +1338,9 @@ export type SignedTxData = {
 	lastValidBlockHeight?: number;
 	blockHash: string;
 };
+
+export type HighLeverageModeConfig = {
+	maxUsers: number;
+	currentUsers: number;
+	reduceOnly: boolean;
+};

package/src/user.ts

@@ -15,7 +15,11 @@ import {
 	UserStatus,
 	UserStatsAccount,
 } from './types';
-import { calculateEntryPrice, positionIsAvailable } from './math/position';
+import {
+	calculateEntryPrice,
+	calculateUnsettledFundingPnl,
+	positionIsAvailable,
+} from './math/position';
 import {
 	AMM_RESERVE_PRECISION,
 	AMM_RESERVE_PRECISION_EXP,
@@ -50,7 +54,6 @@ import {
 	calculateBaseAssetValue,
 	calculateMarketMarginRatio,
 	calculatePerpLiabilityValue,
-	calculatePositionFundingPNL,
 	calculatePositionPNL,
 	calculateReservePrice,
 	calculateSpotMarketMarginRatio,
@@ -100,6 +103,7 @@ import {
 	calculatePerpFuelBonus,
 	calculateInsuranceFuelBonus,
 } from './math/fuel';
+import { grpcUserAccountSubscriber } from './accounts/grpcUserAccountSubscriber';
 
 export class User {
 	driftClient: DriftClient;
@@ -130,6 +134,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.grpcConfigs,
+				config.driftClient.program,
+				config.userAccountPublicKey,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				}
+			);
 		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
@@ -484,7 +498,7 @@ export class User {
 		const nShares = position.lpShares;
 
 		// incorp unsettled funding on pre settled position
-		const quoteFundingPnl = calculatePositionFundingPNL(market, position);
+		const quoteFundingPnl = calculateUnsettledFundingPnl(market, position);
 
 		let baseUnit = AMM_RESERVE_PRECISION;
 		if (market.amm.perLpBase == position.perLpBase) {
@@ -884,13 +898,13 @@ export class User {
 	public getUnrealizedFundingPNL(marketIndex?: number): BN {
 		return this.getUserAccount()
 			.perpPositions.filter((pos) =>
-				marketIndex ? pos.marketIndex === marketIndex : true
+				marketIndex !== undefined ? pos.marketIndex === marketIndex : true
 			)
 			.reduce((pnl, perpPosition) => {
 				const market = this.driftClient.getPerpMarketAccount(
 					perpPosition.marketIndex
 				);
-				return pnl.add(calculatePositionFundingPNL(market, perpPosition));
+				return pnl.add(calculateUnsettledFundingPnl(market, perpPosition));
 			}, ZERO);
 	}
 
@@ -2613,13 +2627,16 @@ export class User {
 
 	public getMarginUSDCRequiredForTrade(
 		targetMarketIndex: number,
-		baseSize: BN
+		baseSize: BN,
+		estEntryPrice?: BN
 	): BN {
 		return calculateMarginUSDCRequiredForTrade(
 			this.driftClient,
 			targetMarketIndex,
 			baseSize,
-			this.getUserAccount().maxMarginRatio
+			this.getUserAccount().maxMarginRatio,
+			undefined,
+			estEntryPrice
 		);
 	}
 

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;
@@ -10,6 +10,12 @@ export type UserConfig = {
 };
 
 export type UserSubscriptionConfig =
+	| {
+			type: 'grpc';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			grpcConfigs: GrpcConfigs;
+	  }
 	| {
 			type: 'websocket';
 			resubTimeoutMs?: number;

package/src/userMap/grpcSubscription.ts

@@ -0,0 +1,78 @@
+import { UserMap } from './userMap';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Context, PublicKey } from '@solana/web3.js';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+
+export class grpcSubscription {
+	private grpcConfigs: GrpcConfigs;
+	private userMap: UserMap;
+	private skipInitialLoad: boolean;
+	private resubOpts?: ResubOpts;
+	private includeIdle?: boolean;
+	private decodeFn: (name: string, data: Buffer) => UserAccount;
+
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+
+	constructor({
+		grpcConfigs,
+		userMap,
+		skipInitialLoad = false,
+		resubOpts,
+		includeIdle = false,
+		decodeFn,
+	}: {
+		grpcConfigs: GrpcConfigs;
+		userMap: UserMap;
+		skipInitialLoad?: boolean;
+		resubOpts?: ResubOpts;
+		includeIdle?: boolean;
+		decodeFn: (name: string, data: Buffer) => UserAccount;
+	}) {
+		this.userMap = userMap;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubOpts = resubOpts;
+		this.includeIdle = includeIdle || false;
+		this.decodeFn = decodeFn;
+		this.grpcConfigs = grpcConfigs;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (!this.subscriber) {
+			const filters = [getUserFilter()];
+			if (!this.includeIdle) {
+				filters.push(getNonIdleUserFilter());
+			}
+			this.subscriber = new grpcProgramAccountSubscriber<UserAccount>(
+				this.grpcConfigs,
+				'UserMap',
+				'User',
+				this.userMap.driftClient.program,
+				this.decodeFn,
+				{
+					filters,
+				},
+				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;
+	}
+}