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

package/VERSION

@@ -1 +1 @@
-2.48.0-beta.2
+2.48.0-beta.3

package/lib/accounts/pollingUserAccountSubscriber.js

@@ -53,12 +53,12 @@ class PollingUserAccountSubscriber {
     }
     async fetch() {
         var _a, _b;
-        await this.accountLoader.load();
-        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.userAccountPublicKey);
-        const currentSlot = (_b = (_a = this.user) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0;
-        if (buffer && slot > currentSlot) {
-            const account = this.program.account.user.coder.accounts.decode('User', buffer);
-            this.user = { data: account, slot };
+        const dataAndContext = await this.program.account.user.fetchAndContext(this.userAccountPublicKey, this.accountLoader.commitment);
+        if ((_b = dataAndContext.context.slot > ((_a = this.user) === null || _a === void 0 ? void 0 : _a.slot)) !== null && _b !== void 0 ? _b : 0) {
+            this.user = {
+                data: dataAndContext.data,
+                slot: dataAndContext.context.slot,
+            };
         }
     }
     doesAccountExist() {
@@ -80,7 +80,9 @@ class PollingUserAccountSubscriber {
         }
     }
     getUserAccountAndSlot() {
-        this.assertIsSubscribed();
+        if (!this.doesAccountExist()) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` or `fetch` before using this function');
+        }
         return this.user;
     }
     updateData(userAccount, slot) {

package/lib/accounts/pollingUserStatsAccountSubscriber.js

@@ -53,12 +53,12 @@ class PollingUserStatsAccountSubscriber {
     }
     async fetch() {
         var _a, _b;
-        await this.accountLoader.load();
-        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.userStatsAccountPublicKey);
-        const currentSlot = (_b = (_a = this.userStats) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0;
-        if (buffer && slot > currentSlot) {
-            const account = this.program.account.userStats.coder.accounts.decodeUnchecked('UserStats', buffer);
-            this.userStats = { data: account, slot };
+        const dataAndContext = await this.program.account.userStats.fetchAndContext(this.userStatsAccountPublicKey, this.accountLoader.commitment);
+        if ((_b = dataAndContext.context.slot > ((_a = this.userStats) === null || _a === void 0 ? void 0 : _a.slot)) !== null && _b !== void 0 ? _b : 0) {
+            this.userStats = {
+                data: dataAndContext.data,
+                slot: dataAndContext.context.slot,
+            };
         }
     }
     doesAccountExist() {
@@ -80,7 +80,9 @@ class PollingUserStatsAccountSubscriber {
         }
     }
     getUserStatsAccountAndSlot() {
-        this.assertIsSubscribed();
+        if (!this.doesAccountExist()) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` or `fetch` before using this function');
+        }
         return this.userStats;
     }
 }

package/lib/userMap/userMap.d.ts

@@ -11,20 +11,30 @@ export interface UserMapInterface {
     updateWithOrderRecord(record: OrderRecord): Promise<void>;
     values(): IterableIterator<User>;
 }
+export type SyncCallbackCriteria = {
+    hasOpenOrders: boolean;
+};
 export declare class UserMap implements UserMapInterface {
     private userMap;
     private driftClient;
     private accountSubscription;
     private includeIdle;
     private lastNumberOfSubAccounts;
+    private stateAccountUpdateCallback;
     private syncCallback;
+    private syncCallbackCriteria;
+    private syncPromise?;
+    private syncPromiseResolver;
     /**
+     * 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?: boolean);
+    constructor(driftClient: DriftClient, accountSubscription: UserSubscriptionConfig, includeIdle?: boolean, syncCallback?: (authorities: PublicKey[]) => Promise<void>, syncCallbackCriteria?: SyncCallbackCriteria);
     subscribe(): Promise<void>;
     addPubkey(userAccountPublicKey: PublicKey, userAccount?: UserAccount): Promise<void>;
     has(key: string): boolean;

package/lib/userMap/userMap.js

@@ -7,14 +7,17 @@ const buffer_1 = require("buffer");
 const memcmp_1 = require("../memcmp");
 class UserMap {
     /**
+     * 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, accountSubscription, includeIdle = false) {
+    constructor(driftClient, accountSubscription, includeIdle = false, syncCallback, syncCallbackCriteria = { hasOpenOrders: false }) {
         this.userMap = new Map();
-        this.syncCallback = async (state) => {
+        this.stateAccountUpdateCallback = async (state) => {
             if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
                 await this.sync();
                 this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
@@ -23,6 +26,8 @@ class UserMap {
         this.driftClient = driftClient;
         this.accountSubscription = accountSubscription;
         this.includeIdle = includeIdle;
+        this.syncCallback = syncCallback;
+        this.syncCallbackCriteria = syncCallbackCriteria;
     }
     async subscribe() {
         if (this.size() > 0) {
@@ -31,7 +36,7 @@ class UserMap {
         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();
     }
     async addPubkey(userAccountPublicKey, userAccount) {
@@ -140,44 +145,73 @@ class UserMap {
         return this.userMap.size;
     }
     async sync() {
-        const filters = [(0, memcmp_1.getUserFilter)()];
-        if (!this.includeIdle) {
-            filters.push((0, memcmp_1.getNonIdleUserFilter)());
-        }
-        const rpcRequestArgs = [
-            this.driftClient.program.programId.toBase58(),
-            {
-                commitment: this.driftClient.connection.commitment,
-                filters,
-                encoding: 'base64',
-                withContext: true,
-            },
-        ];
-        // @ts-ignore
-        const rpcJSONResponse = await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
-        const rpcResponseAndContext = rpcJSONResponse.result;
-        const slot = rpcResponseAndContext.context.slot;
-        const programAccountBufferMap = new Map();
-        for (const programAccount of rpcResponseAndContext.value) {
-            programAccountBufferMap.set(programAccount.pubkey.toString(), 
-            // @ts-ignore
-            buffer_1.Buffer.from(programAccount.account.data[0], programAccount.account.data[1]));
+        if (this.syncPromise) {
+            return this.syncPromise;
         }
-        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 web3_js_1.PublicKey(key), userAccount);
+        this.syncPromise = new Promise((resolver) => {
+            this.syncPromiseResolver = resolver;
+        });
+        try {
+            const filters = [(0, memcmp_1.getUserFilter)()];
+            if (!this.includeIdle) {
+                filters.push((0, memcmp_1.getNonIdleUserFilter)());
             }
-        }
-        for (const [key, user] of this.userMap.entries()) {
-            if (!programAccountBufferMap.has(key)) {
-                await user.unsubscribe();
-                this.userMap.delete(key);
+            const rpcRequestArgs = [
+                this.driftClient.program.programId.toBase58(),
+                {
+                    commitment: this.driftClient.connection.commitment,
+                    filters,
+                    encoding: 'base64',
+                    withContext: true,
+                },
+            ];
+            const rpcJSONResponse = 
+            // @ts-ignore
+            await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+            const rpcResponseAndContext = rpcJSONResponse.result;
+            const slot = rpcResponseAndContext.context.slot;
+            const programAccountBufferMap = new Map();
+            for (const programAccount of rpcResponseAndContext.value) {
+                programAccountBufferMap.set(programAccount.pubkey.toString(), 
+                // @ts-ignore
+                buffer_1.Buffer.from(programAccount.account.data[0], programAccount.account.data[1]));
             }
-            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 web3_js_1.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) {
+                const usersMeetingCriteria = Array.from(this.userMap.values()).filter((user) => {
+                    let pass = true;
+                    if (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 web3_js_1.PublicKey(userAuth));
+                await this.syncCallback(userAuthKeys);
+            }
+        }
+        catch (e) {
+            console.error(`Error in UserMap.sync()`);
+            console.error(e);
+        }
+        finally {
+            this.syncPromiseResolver();
+            this.syncPromise = undefined;
         }
     }
     async unsubscribe() {
@@ -186,7 +220,7 @@ class UserMap {
             this.userMap.delete(key);
         }
         if (this.lastNumberOfSubAccounts) {
-            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.syncCallback);
+            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.stateAccountUpdateCallback);
             this.lastNumberOfSubAccounts = undefined;
         }
     }

package/lib/userMap/userStatsMap.d.ts

@@ -1,4 +1,4 @@
-import { DriftClient, OrderRecord, UserStatsAccount, UserStats, UserStatsSubscriptionConfig, WrappedEvent } from '..';
+import { DriftClient, OrderRecord, UserStatsAccount, UserStats, WrappedEvent, BulkAccountLoader } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { UserMap } from './userMap';
 export declare class UserStatsMap {
@@ -7,19 +7,40 @@ export declare class UserStatsMap {
      */
     private userStatsMap;
     private driftClient;
-    private accountSubscription;
-    private lastNumberOfAuthorities;
-    private syncCallback;
-    constructor(driftClient: DriftClient, accountSubscription: UserStatsSubscriptionConfig);
-    subscribe(): Promise<void>;
-    addUserStat(authority: PublicKey, userStatsAccount?: UserStatsAccount): Promise<void>;
+    private bulkAccountLoader;
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader);
+    subscribe(authorities: PublicKey[]): Promise<void>;
+    /**
+     *
+     * @param authority that owns the UserStatsAccount
+     * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+     * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+     */
+    addUserStat(authority: PublicKey, userStatsAccount?: UserStatsAccount, skipFetch?: boolean): Promise<void>;
     updateWithOrderRecord(record: OrderRecord, userMap: UserMap): Promise<void>;
     updateWithEventRecord(record: WrappedEvent<any>, userMap?: UserMap): Promise<void>;
     has(authorityPublicKey: string): boolean;
     get(authorityPublicKey: string): UserStats;
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
     mustGet(authorityPublicKey: string): Promise<UserStats>;
     values(): IterableIterator<UserStats>;
     size(): number;
-    sync(): Promise<void>;
+    /**
+     * Sync the UserStatsMap
+     * @param authorities list of authorities to derive UserStatsAccount public keys from.
+     * You may want to get this list from UserMap in order to filter out idle users
+     */
+    sync(authorities: PublicKey[]): Promise<void>;
     unsubscribe(): Promise<void>;
 }

package/lib/userMap/userStatsMap.js

@@ -4,43 +4,57 @@ exports.UserStatsMap = void 0;
 const __1 = require("..");
 const web3_js_1 = require("@solana/web3.js");
 class UserStatsMap {
-    constructor(driftClient, accountSubscription) {
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient, bulkAccountLoader) {
         /**
          * map from authority pubkey to UserStats
          */
         this.userStatsMap = new Map();
-        this.syncCallback = async (state) => {
-            if (state.numberOfAuthorities !== this.lastNumberOfAuthorities) {
-                await this.sync();
-                this.lastNumberOfAuthorities = state.numberOfAuthorities;
-            }
-        };
         this.driftClient = driftClient;
-        this.accountSubscription = accountSubscription;
+        if (!bulkAccountLoader) {
+            bulkAccountLoader = new __1.BulkAccountLoader(driftClient.connection, driftClient.opts.commitment, 0);
+        }
+        this.bulkAccountLoader = bulkAccountLoader;
     }
-    async subscribe() {
+    async subscribe(authorities) {
         if (this.size() > 0) {
             return;
         }
         await this.driftClient.subscribe();
-        this.lastNumberOfAuthorities =
-            this.driftClient.getStateAccount().numberOfAuthorities;
-        this.driftClient.eventEmitter.on('stateAccountUpdate', this.syncCallback);
-        await this.sync();
+        await this.sync(authorities);
     }
-    async addUserStat(authority, userStatsAccount) {
+    /**
+     *
+     * @param authority that owns the UserStatsAccount
+     * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+     * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+     */
+    async addUserStat(authority, userStatsAccount, skipFetch) {
         const userStat = new __1.UserStats({
             driftClient: this.driftClient,
             userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, authority),
-            accountSubscription: this.accountSubscription,
+            accountSubscription: {
+                type: 'polling',
+                accountLoader: this.bulkAccountLoader,
+            },
         });
-        await userStat.subscribe(userStatsAccount);
+        if (skipFetch) {
+            await userStat.accountSubscriber.addToAccountLoader();
+        }
+        else {
+            await userStat.subscribe(userStatsAccount);
+        }
         this.userStatsMap.set(authority.toString(), userStat);
     }
     async updateWithOrderRecord(record, userMap) {
         const user = await userMap.mustGet(record.user.toString());
         if (!this.has(user.getUserAccount().authority.toString())) {
-            await this.addUserStat(user.getUserAccount().authority);
+            await this.addUserStat(user.getUserAccount().authority, undefined, false);
         }
     }
     async updateWithEventRecord(record, userMap) {
@@ -114,9 +128,15 @@ class UserStatsMap {
     get(authorityPublicKey) {
         return this.userStatsMap.get(authorityPublicKey);
     }
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
     async mustGet(authorityPublicKey) {
         if (!this.has(authorityPublicKey)) {
-            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey));
+            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey), undefined, false);
         }
         return this.get(authorityPublicKey);
     }
@@ -126,35 +146,21 @@ class UserStatsMap {
     size() {
         return this.userStatsMap.size;
     }
-    async sync() {
-        const programAccounts = await this.driftClient.connection.getProgramAccounts(this.driftClient.program.programId, {
-            commitment: this.driftClient.connection.commitment,
-            filters: [
-                {
-                    memcmp: this.driftClient.program.coder.accounts.memcmp('UserStats'),
-                },
-            ],
-        });
-        const programAccountMap = new Map();
-        for (const programAccount of programAccounts) {
-            programAccountMap.set(new web3_js_1.PublicKey(programAccount.account.data.slice(8, 40)).toString(), programAccount.account);
-        }
-        for (const key of programAccountMap.keys()) {
-            if (!this.has(key)) {
-                const userStatsAccount = this.driftClient.program.account.userStats.coder.accounts.decode('UserStats', programAccountMap.get(key).data);
-                await this.addUserStat(new web3_js_1.PublicKey(key), userStatsAccount);
-            }
-        }
+    /**
+     * Sync the UserStatsMap
+     * @param authorities list of authorities to derive UserStatsAccount public keys from.
+     * You may want to get this list from UserMap in order to filter out idle users
+     */
+    async sync(authorities) {
+        console.log(`USER MAP SIYCING AUTHS: ${authorities.length}`);
+        await Promise.all(authorities.map((authority) => this.addUserStat(authority, undefined, true)));
+        await this.bulkAccountLoader.load();
     }
     async unsubscribe() {
         for (const [key, userStats] of this.userStatsMap.entries()) {
             await userStats.unsubscribe();
             this.userStatsMap.delete(key);
         }
-        if (this.lastNumberOfAuthorities) {
-            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.syncCallback);
-            this.lastNumberOfAuthorities = undefined;
-        }
     }
 }
 exports.UserStatsMap = UserStatsMap;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.48.0-beta.2",
+	"version": "2.48.0-beta.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -93,17 +93,15 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	async fetch(): Promise<void> {
-		await this.accountLoader.load();
-		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
-			this.userAccountPublicKey
+		const dataAndContext = await this.program.account.user.fetchAndContext(
+			this.userAccountPublicKey,
+			this.accountLoader.commitment
 		);
-		const currentSlot = this.user?.slot ?? 0;
-		if (buffer && slot > currentSlot) {
-			const account = this.program.account.user.coder.accounts.decode(
-				'User',
-				buffer
-			);
-			this.user = { data: account, slot };
+		if (dataAndContext.context.slot > this.user?.slot ?? 0) {
+			this.user = {
+				data: dataAndContext.data as UserAccount,
+				slot: dataAndContext.context.slot,
+			};
 		}
 	}
 
@@ -137,7 +135,11 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	public getUserAccountAndSlot(): DataAndSlot<UserAccount> {
-		this.assertIsSubscribed();
+		if (!this.doesAccountExist()) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` or `fetch` before using this function'
+			);
+		}
 		return this.user;
 	}
 

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -97,18 +97,15 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	async fetch(): Promise<void> {
-		await this.accountLoader.load();
-		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
-			this.userStatsAccountPublicKey
+		const dataAndContext = await this.program.account.userStats.fetchAndContext(
+			this.userStatsAccountPublicKey,
+			this.accountLoader.commitment
 		);
-		const currentSlot = this.userStats?.slot ?? 0;
-		if (buffer && slot > currentSlot) {
-			const account =
-				this.program.account.userStats.coder.accounts.decodeUnchecked(
-					'UserStats',
-					buffer
-				);
-			this.userStats = { data: account, slot };
+		if (dataAndContext.context.slot > this.userStats?.slot ?? 0) {
+			this.userStats = {
+				data: dataAndContext.data as UserStatsAccount,
+				slot: dataAndContext.context.slot,
+			};
 		}
 	}
 
@@ -142,7 +139,11 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
-		this.assertIsSubscribed();
+		if (!this.doesAccountExist()) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` or `fetch` before using this function'
+			);
+		}
 		return this.userStats;
 	}
 }

package/src/userMap/userMap.ts

@@ -32,33 +32,51 @@ 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 async subscribe() {
@@ -69,7 +87,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();
 	}
@@ -188,73 +209,110 @@ export class UserMap implements UserMapInterface {
 	}
 
 	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 rpcRequestArgs = [
+				this.driftClient.program.programId.toBase58(),
+				{
+					commitment: this.driftClient.connection.commitment,
+					filters,
+					encoding: 'base64',
+					withContext: true,
+				},
+			];
 
-		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 rpcJSONResponse: any =
 				// @ts-ignore
-				Buffer.from(
-					programAccount.account.data[0],
-					programAccount.account.data[1]
-				)
-			);
-		}
+				await this.driftClient.connection._rpcRequest(
+					'getProgramAccounts',
+					rpcRequestArgs
+				);
 
-		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 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(),
+					// @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) {
+				const usersMeetingCriteria = Array.from(this.userMap.values()).filter(
+					(user) => {
+						let pass = true;
+						if (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)
+				);
+				await this.syncCallback(userAuthKeys);
 			}
+		} catch (e) {
+			console.error(`Error in UserMap.sync()`);
+			console.error(e);
+		} finally {
+			this.syncPromiseResolver();
+			this.syncPromise = undefined;
 		}
 	}
 
@@ -267,7 +325,7 @@ export class UserMap implements UserMapInterface {
 		if (this.lastNumberOfSubAccounts) {
 			this.driftClient.eventEmitter.removeListener(
 				'stateAccountUpdate',
-				this.syncCallback
+				this.stateAccountUpdateCallback
 			);
 			this.lastNumberOfSubAccounts = undefined;
 		}

package/src/userMap/userStatsMap.ts

@@ -4,7 +4,6 @@ import {
 	OrderRecord,
 	UserStatsAccount,
 	UserStats,
-	UserStatsSubscriptionConfig,
 	WrappedEvent,
 	DepositRecord,
 	FundingPaymentRecord,
@@ -14,12 +13,12 @@ import {
 	NewUserRecord,
 	LPRecord,
 	InsuranceFundStakeRecord,
-	StateAccount,
+	BulkAccountLoader,
+	PollingUserStatsAccountSubscriber,
 } from '..';
-import { AccountInfo, PublicKey } from '@solana/web3.js';
+import { PublicKey } from '@solana/web3.js';
 
 import { UserMap } from './userMap';
-import { Buffer } from 'buffer';
 
 export class UserStatsMap {
 	/**
@@ -27,39 +26,45 @@ export class UserStatsMap {
 	 */
 	private userStatsMap = new Map<string, UserStats>();
 	private driftClient: DriftClient;
-	private accountSubscription: UserStatsSubscriptionConfig;
-	private lastNumberOfAuthorities;
-	private syncCallback = async (state: StateAccount) => {
-		if (state.numberOfAuthorities !== this.lastNumberOfAuthorities) {
-			await this.sync();
-			this.lastNumberOfAuthorities = state.numberOfAuthorities;
-		}
-	};
+	private bulkAccountLoader: BulkAccountLoader;
 
-	constructor(
-		driftClient: DriftClient,
-		accountSubscription: UserStatsSubscriptionConfig
-	) {
+	/**
+	 * Creates a new UserStatsMap instance.
+	 *
+	 * @param {DriftClient} driftClient - The DriftClient instance.
+	 * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+	 */
+	constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader) {
 		this.driftClient = driftClient;
-		this.accountSubscription = accountSubscription;
+		if (!bulkAccountLoader) {
+			bulkAccountLoader = new BulkAccountLoader(
+				driftClient.connection,
+				driftClient.opts.commitment,
+				0
+			);
+		}
+		this.bulkAccountLoader = bulkAccountLoader;
 	}
 
-	public async subscribe() {
+	public async subscribe(authorities: PublicKey[]) {
 		if (this.size() > 0) {
 			return;
 		}
 
 		await this.driftClient.subscribe();
-		this.lastNumberOfAuthorities =
-			this.driftClient.getStateAccount().numberOfAuthorities;
-		this.driftClient.eventEmitter.on('stateAccountUpdate', this.syncCallback);
-
-		await this.sync();
+		await this.sync(authorities);
 	}
 
+	/**
+	 *
+	 * @param authority that owns the UserStatsAccount
+	 * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+	 * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+	 */
 	public async addUserStat(
 		authority: PublicKey,
-		userStatsAccount?: UserStatsAccount
+		userStatsAccount?: UserStatsAccount,
+		skipFetch?: boolean
 	) {
 		const userStat = new UserStats({
 			driftClient: this.driftClient,
@@ -67,9 +72,18 @@ export class UserStatsMap {
 				this.driftClient.program.programId,
 				authority
 			),
-			accountSubscription: this.accountSubscription,
+			accountSubscription: {
+				type: 'polling',
+				accountLoader: this.bulkAccountLoader,
+			},
 		});
-		await userStat.subscribe(userStatsAccount);
+		if (skipFetch) {
+			await (
+				userStat.accountSubscriber as PollingUserStatsAccountSubscriber
+			).addToAccountLoader();
+		} else {
+			await userStat.subscribe(userStatsAccount);
+		}
 
 		this.userStatsMap.set(authority.toString(), userStat);
 	}
@@ -77,7 +91,7 @@ export class UserStatsMap {
 	public async updateWithOrderRecord(record: OrderRecord, userMap: UserMap) {
 		const user = await userMap.mustGet(record.user.toString());
 		if (!this.has(user.getUserAccount().authority.toString())) {
-			await this.addUserStat(user.getUserAccount().authority);
+			await this.addUserStat(user.getUserAccount().authority, undefined, false);
 		}
 	}
 
@@ -156,9 +170,19 @@ export class UserStatsMap {
 		return this.userStatsMap.get(authorityPublicKey);
 	}
 
+	/**
+	 * Enforce that a UserStats will exist for the given authorityPublicKey,
+	 * reading one from the blockchain if necessary.
+	 * @param authorityPublicKey
+	 * @returns
+	 */
 	public async mustGet(authorityPublicKey: string): Promise<UserStats> {
 		if (!this.has(authorityPublicKey)) {
-			await this.addUserStat(new PublicKey(authorityPublicKey));
+			await this.addUserStat(
+				new PublicKey(authorityPublicKey),
+				undefined,
+				false
+			);
 		}
 		return this.get(authorityPublicKey);
 	}
@@ -171,39 +195,19 @@ export class UserStatsMap {
 		return this.userStatsMap.size;
 	}
 
-	public async sync() {
-		const programAccounts =
-			await this.driftClient.connection.getProgramAccounts(
-				this.driftClient.program.programId,
-				{
-					commitment: this.driftClient.connection.commitment,
-					filters: [
-						{
-							memcmp:
-								this.driftClient.program.coder.accounts.memcmp('UserStats'),
-						},
-					],
-				}
-			);
-
-		const programAccountMap = new Map<string, AccountInfo<Buffer>>();
-		for (const programAccount of programAccounts) {
-			programAccountMap.set(
-				new PublicKey(programAccount.account.data.slice(8, 40)).toString(),
-				programAccount.account
-			);
-		}
-
-		for (const key of programAccountMap.keys()) {
-			if (!this.has(key)) {
-				const userStatsAccount =
-					this.driftClient.program.account.userStats.coder.accounts.decode(
-						'UserStats',
-						programAccountMap.get(key).data
-					);
-				await this.addUserStat(new PublicKey(key), userStatsAccount);
-			}
-		}
+	/**
+	 * Sync the UserStatsMap
+	 * @param authorities list of authorities to derive UserStatsAccount public keys from.
+	 * You may want to get this list from UserMap in order to filter out idle users
+	 */
+	public async sync(authorities: PublicKey[]) {
+		console.log(`USER MAP SIYCING AUTHS: ${authorities.length}`);
+		await Promise.all(
+			authorities.map((authority) =>
+				this.addUserStat(authority, undefined, true)
+			)
+		);
+		await this.bulkAccountLoader.load();
 	}
 
 	public async unsubscribe() {
@@ -211,13 +215,5 @@ export class UserStatsMap {
 			await userStats.unsubscribe();
 			this.userStatsMap.delete(key);
 		}
-
-		if (this.lastNumberOfAuthorities) {
-			this.driftClient.eventEmitter.removeListener(
-				'stateAccountUpdate',
-				this.syncCallback
-			);
-			this.lastNumberOfAuthorities = undefined;
-		}
 	}
 }

package/tests/amm/test.ts

@@ -967,8 +967,9 @@ describe('AMM Tests', () => {
 		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(
 			new BN(9)
 		);
-		mockMarket1.amm.minBaseAssetReserve =
-			mockMarket1.amm.baseAssetReserve.sub(new BN(9));
+		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.sub(
+			new BN(9)
+		);
 		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
 		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
 		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);

package/tests/dlob/test.ts

@@ -27,7 +27,7 @@ import {
 
 import { mockPerpMarkets, mockSpotMarkets, mockStateAccount } from './helpers';
 import { DLOBOrdersCoder } from '../../src/dlob/DLOBOrders';
-import {isAuctionComplete, isRestingLimitOrder} from "../../lib";
+import { isAuctionComplete, isRestingLimitOrder } from '../../lib';
 
 function insertOrderToDLOB(
 	dlob: DLOB,
@@ -2537,18 +2537,21 @@ describe('DLOB Perp Tests', () => {
 			OrderTriggerCondition.TRIGGERED_ABOVE, // triggerCondition: OrderTriggerCondition,
 			vBid,
 			vAsk,
-			new BN(1), // slot
+			new BN(1) // slot
 		);
 
-		const restingLimitBids = Array.from(dlob.getRestingLimitBids(marketIndex, slot, MarketType.PERP, oracle));
+		const restingLimitBids = Array.from(
+			dlob.getRestingLimitBids(marketIndex, slot, MarketType.PERP, oracle)
+		);
 		expect(restingLimitBids.length).to.equal(0);
 
-		const takingBids = Array.from(dlob.getTakingBids(marketIndex, MarketType.PERP, slot, oracle));
+		const takingBids = Array.from(
+			dlob.getTakingBids(marketIndex, MarketType.PERP, slot, oracle)
+		);
 		expect(takingBids.length).to.equal(1);
 		const triggerLimitBid = takingBids[0];
 		expect(isAuctionComplete(triggerLimitBid.order, slot)).to.equal(true);
 		expect(isRestingLimitOrder(triggerLimitBid.order, slot)).to.equal(false);
-
 	});
 
 	it('Test will return expired market orders to fill', () => {