@drift-labs/sdk-browser 2.109.0-beta.5 → 2.109.0-beta.7

package/VERSION

@@ -1 +1 @@
-2.109.0-beta.5
+2.109.0-beta.7

package/lib/browser/driftClient.d.ts

@@ -888,8 +888,8 @@ export declare class DriftClient {
     disableUserHighLeverageMode(user: PublicKey, userAccount?: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
     getDisableHighLeverageModeIx(user: PublicKey, userAccount?: UserAccount): Promise<TransactionInstruction>;
     fetchHighLeverageModeConfig(): Promise<HighLeverageModeConfig>;
-    updateUserProtectedMakerOrders(subAccountId: number, protectedOrders: boolean, txParams?: TxParams): Promise<TransactionSignature>;
-    getUpdateUserProtectedMakerOrdersIx(subAccountId: number, protectedOrders: boolean): Promise<TransactionInstruction>;
+    updateUserProtectedMakerOrders(subAccountId: number, protectedOrders: boolean, authority?: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateUserProtectedMakerOrdersIx(subAccountId: number, protectedOrders: boolean, authority?: PublicKey): Promise<TransactionInstruction>;
     getPauseSpotMarketDepositWithdrawIx(spotMarketIndex: number): Promise<TransactionInstruction>;
     pauseSpotMarketDepositWithdraw(spotMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     private handleSignedTransaction;

package/lib/browser/driftClient.js

@@ -4847,15 +4847,15 @@ class DriftClient {
         const config = await this.program.account.highLeverageModeConfig.fetch((0, pda_1.getHighLeverageModeConfigPublicKey)(this.program.programId));
         return config;
     }
-    async updateUserProtectedMakerOrders(subAccountId, protectedOrders, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders), txParams), [], this.opts);
+    async updateUserProtectedMakerOrders(subAccountId, protectedOrders, authority, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders, authority), txParams), [], this.opts);
         return txSig;
     }
-    async getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders) {
+    async getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders, authority) {
         const ix = await this.program.instruction.updateUserProtectedMakerOrders(subAccountId, protectedOrders, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId),
+                user: (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, authority !== null && authority !== void 0 ? authority : this.authority, subAccountId),
                 authority: this.wallet.publicKey,
                 protectedMakerModeConfig: (0, pda_1.getProtectedMakerModeConfigPublicKey)(this.program.programId),
             },

package/lib/browser/userMap/userMap.d.ts

@@ -81,7 +81,17 @@ export declare class UserMap implements UserMapInterface {
      */
     getUniqueAuthorities(filterCriteria?: UserFilterCriteria): PublicKey[];
     sync(): Promise<void>;
+    /**
+     * Syncs the UserMap using the default sync method (single getProgramAccounts call with filters).
+     * This method may fail when drift has too many users. (nodejs response size limits)
+     * @returns
+     */
     private defaultSync;
+    /**
+     * Syncs the UserMap using the paginated sync method (multiple getMultipleAccounts calls with filters).
+     * This method is more reliable when drift has many users.
+     * @returns
+     */
     private paginatedSync;
     unsubscribe(): Promise<void>;
     updateUserAccount(key: string, userAccount: UserAccount, slot: number): Promise<void>;

package/lib/browser/userMap/userMap.js

@@ -259,6 +259,11 @@ class UserMap {
             return this.paginatedSync();
         }
     }
+    /**
+     * Syncs the UserMap using the default sync method (single getProgramAccounts call with filters).
+     * This method may fail when drift has too many users. (nodejs response size limits)
+     * @returns
+     */
     async defaultSync() {
         var _a;
         if (this.syncPromise) {
@@ -334,6 +339,11 @@ class UserMap {
             this.syncPromise = undefined;
         }
     }
+    /**
+     * Syncs the UserMap using the paginated sync method (multiple getMultipleAccounts calls with filters).
+     * This method is more reliable when drift has many users.
+     * @returns
+     */
     async paginatedSync() {
         var _a, _b;
         if (this.syncPromise) {

package/lib/browser/userMap/userStatsMap.d.ts

@@ -1,4 +1,4 @@
-import { DriftClient, OrderRecord, UserStatsAccount, UserStats, WrappedEvent, BulkAccountLoader } from '..';
+import { DriftClient, OrderRecord, UserStatsAccount, UserStats, WrappedEvent, BulkAccountLoader, SyncConfig } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { UserMap } from './userMap';
 export declare class UserStatsMap {
@@ -8,13 +8,17 @@ export declare class UserStatsMap {
     private userStatsMap;
     private driftClient;
     private bulkAccountLoader;
+    private decode;
+    private syncConfig;
+    private syncPromise?;
+    private syncPromiseResolver;
     /**
      * 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);
+    constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader, syncConfig?: SyncConfig);
     subscribe(authorities: PublicKey[]): Promise<void>;
     /**
      *
@@ -42,5 +46,16 @@ export declare class UserStatsMap {
      * You may want to get this list from UserMap in order to filter out idle users
      */
     sync(authorities: PublicKey[]): Promise<void>;
+    /**
+     * Sync the UserStatsMap using the default sync method, which loads individual users into the bulkAccountLoader and
+     * loads them. (bulkAccountLoader uses batch getMultipleAccounts)
+     * @param authorities
+     */
+    private defaultSync;
+    /**
+     * Sync the UserStatsMap using the paginated sync method, which uses multiple getMultipleAccounts calls (without RPC batching), and limits concurrency.
+     * @param authorities
+     */
+    private paginatedSync;
     unsubscribe(): Promise<void>;
 }

package/lib/browser/userMap/userStatsMap.js

@@ -10,7 +10,7 @@ class UserStatsMap {
      * @param {DriftClient} driftClient - The DriftClient instance.
      * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
      */
-    constructor(driftClient, bulkAccountLoader) {
+    constructor(driftClient, bulkAccountLoader, syncConfig) {
         /**
          * map from authority pubkey to UserStats
          */
@@ -20,6 +20,11 @@ class UserStatsMap {
             bulkAccountLoader = new __1.BulkAccountLoader(driftClient.connection, driftClient.opts.commitment, 0);
         }
         this.bulkAccountLoader = bulkAccountLoader;
+        this.syncConfig = syncConfig !== null && syncConfig !== void 0 ? syncConfig : {
+            type: 'default',
+        };
+        this.decode =
+            this.driftClient.program.account.userStats.coder.accounts.decodeUnchecked.bind(this.driftClient.program.account.userStats.coder.accounts);
     }
     async subscribe(authorities) {
         if (this.size() > 0) {
@@ -152,9 +157,111 @@ class UserStatsMap {
      * You may want to get this list from UserMap in order to filter out idle users
      */
     async sync(authorities) {
+        if (this.syncConfig.type === 'default') {
+            return this.defaultSync(authorities);
+        }
+        else {
+            return this.paginatedSync(authorities);
+        }
+    }
+    /**
+     * Sync the UserStatsMap using the default sync method, which loads individual users into the bulkAccountLoader and
+     * loads them. (bulkAccountLoader uses batch getMultipleAccounts)
+     * @param authorities
+     */
+    async defaultSync(authorities) {
         await Promise.all(authorities.map((authority) => this.addUserStat(authority, undefined, true)));
         await this.bulkAccountLoader.load();
     }
+    /**
+     * Sync the UserStatsMap using the paginated sync method, which uses multiple getMultipleAccounts calls (without RPC batching), and limits concurrency.
+     * @param authorities
+     */
+    async paginatedSync(authorities) {
+        var _a, _b;
+        if (this.syncPromise) {
+            return this.syncPromise;
+        }
+        this.syncPromise = new Promise((resolve) => {
+            this.syncPromiseResolver = resolve;
+        });
+        try {
+            let accountsToLoad = authorities;
+            if (authorities.length === 0) {
+                const accountsPrefetch = await this.driftClient.connection.getProgramAccounts(this.driftClient.program.programId, {
+                    dataSlice: { offset: 0, length: 0 },
+                    filters: [(0, __1.getUserStatsFilter)()],
+                });
+                accountsToLoad = accountsPrefetch.map((account) => account.pubkey);
+            }
+            const limitConcurrency = async (tasks, limit) => {
+                const executing = [];
+                const results = [];
+                for (let i = 0; i < tasks.length; i++) {
+                    const executor = Promise.resolve().then(tasks[i]);
+                    results.push(executor);
+                    if (executing.length < limit) {
+                        executing.push(executor);
+                        executor.finally(() => {
+                            const index = executing.indexOf(executor);
+                            if (index > -1) {
+                                executing.splice(index, 1);
+                            }
+                        });
+                    }
+                    else {
+                        await Promise.race(executing);
+                    }
+                }
+                return Promise.all(results);
+            };
+            const programAccountBufferMap = new Set();
+            // @ts-ignore
+            const chunkSize = (_a = this.syncConfig.chunkSize) !== null && _a !== void 0 ? _a : 100;
+            const tasks = [];
+            for (let i = 0; i < accountsToLoad.length; i += chunkSize) {
+                const chunk = accountsToLoad.slice(i, i + chunkSize);
+                tasks.push(async () => {
+                    const accountInfos = await this.driftClient.connection.getMultipleAccountsInfoAndContext(chunk, {
+                        commitment: this.driftClient.opts.commitment,
+                    });
+                    for (let j = 0; j < accountInfos.value.length; j += 1) {
+                        const accountInfo = accountInfos.value[j];
+                        if (accountInfo === null)
+                            continue;
+                        const publicKeyString = chunk[j].toString();
+                        if (!this.has(publicKeyString)) {
+                            const buffer = Buffer.from(accountInfo.data);
+                            const decodedUserStats = this.decode('UserStats', buffer);
+                            programAccountBufferMap.add(decodedUserStats.authority.toBase58());
+                            this.addUserStat(decodedUserStats.authority, decodedUserStats, false);
+                        }
+                    }
+                });
+            }
+            // @ts-ignore
+            const concurrencyLimit = (_b = this.syncConfig.concurrencyLimit) !== null && _b !== void 0 ? _b : 10;
+            await limitConcurrency(tasks, concurrencyLimit);
+            for (const [key] of this.userStatsMap.entries()) {
+                if (!programAccountBufferMap.has(key)) {
+                    const user = this.get(key);
+                    if (user) {
+                        await user.unsubscribe();
+                        this.userStatsMap.delete(key);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error in UserStatsMap.paginatedSync():`, err);
+        }
+        finally {
+            if (this.syncPromiseResolver) {
+                this.syncPromiseResolver();
+            }
+            this.syncPromise = undefined;
+        }
+    }
     async unsubscribe() {
         for (const [key, userStats] of this.userStatsMap.entries()) {
             await userStats.unsubscribe();

package/lib/node/driftClient.d.ts

@@ -888,8 +888,8 @@ export declare class DriftClient {
     disableUserHighLeverageMode(user: PublicKey, userAccount?: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
     getDisableHighLeverageModeIx(user: PublicKey, userAccount?: UserAccount): Promise<TransactionInstruction>;
     fetchHighLeverageModeConfig(): Promise<HighLeverageModeConfig>;
-    updateUserProtectedMakerOrders(subAccountId: number, protectedOrders: boolean, txParams?: TxParams): Promise<TransactionSignature>;
-    getUpdateUserProtectedMakerOrdersIx(subAccountId: number, protectedOrders: boolean): Promise<TransactionInstruction>;
+    updateUserProtectedMakerOrders(subAccountId: number, protectedOrders: boolean, authority?: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateUserProtectedMakerOrdersIx(subAccountId: number, protectedOrders: boolean, authority?: PublicKey): Promise<TransactionInstruction>;
     getPauseSpotMarketDepositWithdrawIx(spotMarketIndex: number): Promise<TransactionInstruction>;
     pauseSpotMarketDepositWithdraw(spotMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     private handleSignedTransaction;

package/lib/node/driftClient.js

@@ -4847,15 +4847,15 @@ class DriftClient {
         const config = await this.program.account.highLeverageModeConfig.fetch((0, pda_1.getHighLeverageModeConfigPublicKey)(this.program.programId));
         return config;
     }
-    async updateUserProtectedMakerOrders(subAccountId, protectedOrders, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders), txParams), [], this.opts);
+    async updateUserProtectedMakerOrders(subAccountId, protectedOrders, authority, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders, authority), txParams), [], this.opts);
         return txSig;
     }
-    async getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders) {
+    async getUpdateUserProtectedMakerOrdersIx(subAccountId, protectedOrders, authority) {
         const ix = await this.program.instruction.updateUserProtectedMakerOrders(subAccountId, protectedOrders, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId),
+                user: (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, authority !== null && authority !== void 0 ? authority : this.authority, subAccountId),
                 authority: this.wallet.publicKey,
                 protectedMakerModeConfig: (0, pda_1.getProtectedMakerModeConfigPublicKey)(this.program.programId),
             },

package/lib/node/userMap/userMap.d.ts

@@ -81,7 +81,17 @@ export declare class UserMap implements UserMapInterface {
      */
     getUniqueAuthorities(filterCriteria?: UserFilterCriteria): PublicKey[];
     sync(): Promise<void>;
+    /**
+     * Syncs the UserMap using the default sync method (single getProgramAccounts call with filters).
+     * This method may fail when drift has too many users. (nodejs response size limits)
+     * @returns
+     */
     private defaultSync;
+    /**
+     * Syncs the UserMap using the paginated sync method (multiple getMultipleAccounts calls with filters).
+     * This method is more reliable when drift has many users.
+     * @returns
+     */
     private paginatedSync;
     unsubscribe(): Promise<void>;
     updateUserAccount(key: string, userAccount: UserAccount, slot: number): Promise<void>;

package/lib/node/userMap/userMap.js

@@ -259,6 +259,11 @@ class UserMap {
             return this.paginatedSync();
         }
     }
+    /**
+     * Syncs the UserMap using the default sync method (single getProgramAccounts call with filters).
+     * This method may fail when drift has too many users. (nodejs response size limits)
+     * @returns
+     */
     async defaultSync() {
         var _a;
         if (this.syncPromise) {
@@ -334,6 +339,11 @@ class UserMap {
             this.syncPromise = undefined;
         }
     }
+    /**
+     * Syncs the UserMap using the paginated sync method (multiple getMultipleAccounts calls with filters).
+     * This method is more reliable when drift has many users.
+     * @returns
+     */
     async paginatedSync() {
         var _a, _b;
         if (this.syncPromise) {

package/lib/node/userMap/userStatsMap.d.ts

@@ -1,4 +1,4 @@
-import { DriftClient, OrderRecord, UserStatsAccount, UserStats, WrappedEvent, BulkAccountLoader } from '..';
+import { DriftClient, OrderRecord, UserStatsAccount, UserStats, WrappedEvent, BulkAccountLoader, SyncConfig } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { UserMap } from './userMap';
 export declare class UserStatsMap {
@@ -8,13 +8,17 @@ export declare class UserStatsMap {
     private userStatsMap;
     private driftClient;
     private bulkAccountLoader;
+    private decode;
+    private syncConfig;
+    private syncPromise?;
+    private syncPromiseResolver;
     /**
      * 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);
+    constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader, syncConfig?: SyncConfig);
     subscribe(authorities: PublicKey[]): Promise<void>;
     /**
      *
@@ -42,5 +46,16 @@ export declare class UserStatsMap {
      * You may want to get this list from UserMap in order to filter out idle users
      */
     sync(authorities: PublicKey[]): Promise<void>;
+    /**
+     * Sync the UserStatsMap using the default sync method, which loads individual users into the bulkAccountLoader and
+     * loads them. (bulkAccountLoader uses batch getMultipleAccounts)
+     * @param authorities
+     */
+    private defaultSync;
+    /**
+     * Sync the UserStatsMap using the paginated sync method, which uses multiple getMultipleAccounts calls (without RPC batching), and limits concurrency.
+     * @param authorities
+     */
+    private paginatedSync;
     unsubscribe(): Promise<void>;
 }

package/lib/node/userMap/userStatsMap.js

@@ -10,7 +10,7 @@ class UserStatsMap {
      * @param {DriftClient} driftClient - The DriftClient instance.
      * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
      */
-    constructor(driftClient, bulkAccountLoader) {
+    constructor(driftClient, bulkAccountLoader, syncConfig) {
         /**
          * map from authority pubkey to UserStats
          */
@@ -20,6 +20,11 @@ class UserStatsMap {
             bulkAccountLoader = new __1.BulkAccountLoader(driftClient.connection, driftClient.opts.commitment, 0);
         }
         this.bulkAccountLoader = bulkAccountLoader;
+        this.syncConfig = syncConfig !== null && syncConfig !== void 0 ? syncConfig : {
+            type: 'default',
+        };
+        this.decode =
+            this.driftClient.program.account.userStats.coder.accounts.decodeUnchecked.bind(this.driftClient.program.account.userStats.coder.accounts);
     }
     async subscribe(authorities) {
         if (this.size() > 0) {
@@ -152,9 +157,111 @@ class UserStatsMap {
      * You may want to get this list from UserMap in order to filter out idle users
      */
     async sync(authorities) {
+        if (this.syncConfig.type === 'default') {
+            return this.defaultSync(authorities);
+        }
+        else {
+            return this.paginatedSync(authorities);
+        }
+    }
+    /**
+     * Sync the UserStatsMap using the default sync method, which loads individual users into the bulkAccountLoader and
+     * loads them. (bulkAccountLoader uses batch getMultipleAccounts)
+     * @param authorities
+     */
+    async defaultSync(authorities) {
         await Promise.all(authorities.map((authority) => this.addUserStat(authority, undefined, true)));
         await this.bulkAccountLoader.load();
     }
+    /**
+     * Sync the UserStatsMap using the paginated sync method, which uses multiple getMultipleAccounts calls (without RPC batching), and limits concurrency.
+     * @param authorities
+     */
+    async paginatedSync(authorities) {
+        var _a, _b;
+        if (this.syncPromise) {
+            return this.syncPromise;
+        }
+        this.syncPromise = new Promise((resolve) => {
+            this.syncPromiseResolver = resolve;
+        });
+        try {
+            let accountsToLoad = authorities;
+            if (authorities.length === 0) {
+                const accountsPrefetch = await this.driftClient.connection.getProgramAccounts(this.driftClient.program.programId, {
+                    dataSlice: { offset: 0, length: 0 },
+                    filters: [(0, __1.getUserStatsFilter)()],
+                });
+                accountsToLoad = accountsPrefetch.map((account) => account.pubkey);
+            }
+            const limitConcurrency = async (tasks, limit) => {
+                const executing = [];
+                const results = [];
+                for (let i = 0; i < tasks.length; i++) {
+                    const executor = Promise.resolve().then(tasks[i]);
+                    results.push(executor);
+                    if (executing.length < limit) {
+                        executing.push(executor);
+                        executor.finally(() => {
+                            const index = executing.indexOf(executor);
+                            if (index > -1) {
+                                executing.splice(index, 1);
+                            }
+                        });
+                    }
+                    else {
+                        await Promise.race(executing);
+                    }
+                }
+                return Promise.all(results);
+            };
+            const programAccountBufferMap = new Set();
+            // @ts-ignore
+            const chunkSize = (_a = this.syncConfig.chunkSize) !== null && _a !== void 0 ? _a : 100;
+            const tasks = [];
+            for (let i = 0; i < accountsToLoad.length; i += chunkSize) {
+                const chunk = accountsToLoad.slice(i, i + chunkSize);
+                tasks.push(async () => {
+                    const accountInfos = await this.driftClient.connection.getMultipleAccountsInfoAndContext(chunk, {
+                        commitment: this.driftClient.opts.commitment,
+                    });
+                    for (let j = 0; j < accountInfos.value.length; j += 1) {
+                        const accountInfo = accountInfos.value[j];
+                        if (accountInfo === null)
+                            continue;
+                        const publicKeyString = chunk[j].toString();
+                        if (!this.has(publicKeyString)) {
+                            const buffer = Buffer.from(accountInfo.data);
+                            const decodedUserStats = this.decode('UserStats', buffer);
+                            programAccountBufferMap.add(decodedUserStats.authority.toBase58());
+                            this.addUserStat(decodedUserStats.authority, decodedUserStats, false);
+                        }
+                    }
+                });
+            }
+            // @ts-ignore
+            const concurrencyLimit = (_b = this.syncConfig.concurrencyLimit) !== null && _b !== void 0 ? _b : 10;
+            await limitConcurrency(tasks, concurrencyLimit);
+            for (const [key] of this.userStatsMap.entries()) {
+                if (!programAccountBufferMap.has(key)) {
+                    const user = this.get(key);
+                    if (user) {
+                        await user.unsubscribe();
+                        this.userStatsMap.delete(key);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error in UserStatsMap.paginatedSync():`, err);
+        }
+        finally {
+            if (this.syncPromiseResolver) {
+                this.syncPromiseResolver();
+            }
+            this.syncPromise = undefined;
+        }
+    }
     async unsubscribe() {
         for (const [key, userStats] of this.userStatsMap.entries()) {
             await userStats.unsubscribe();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/sdk-browser",
-  "version": "2.109.0-beta.5",
+  "version": "2.109.0-beta.7",
   "main": "lib/node/index.js",
   "types": "lib/node/index.d.ts",
   "browser": "./lib/browser/index.js",

package/src/driftClient.ts

@@ -9209,13 +9209,15 @@ export class DriftClient {
 	public async updateUserProtectedMakerOrders(
 		subAccountId: number,
 		protectedOrders: boolean,
+		authority?: PublicKey,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(
 				await this.getUpdateUserProtectedMakerOrdersIx(
 					subAccountId,
-					protectedOrders
+					protectedOrders,
+					authority
 				),
 				txParams
 			),
@@ -9227,7 +9229,8 @@ export class DriftClient {
 
 	public async getUpdateUserProtectedMakerOrdersIx(
 		subAccountId: number,
-		protectedOrders: boolean
+		protectedOrders: boolean,
+		authority?: PublicKey
 	): Promise<TransactionInstruction> {
 		const ix = await this.program.instruction.updateUserProtectedMakerOrders(
 			subAccountId,
@@ -9237,7 +9240,7 @@ export class DriftClient {
 					state: await this.getStatePublicKey(),
 					user: getUserAccountPublicKeySync(
 						this.program.programId,
-						this.wallet.publicKey,
+						authority ?? this.authority,
 						subAccountId
 					),
 					authority: this.wallet.publicKey,

package/src/userMap/userMap.ts

@@ -388,6 +388,11 @@ export class UserMap implements UserMapInterface {
 		}
 	}
 
+	/**
+	 * Syncs the UserMap using the default sync method (single getProgramAccounts call with filters).
+	 * This method may fail when drift has too many users. (nodejs response size limits)
+	 * @returns
+	 */
 	private async defaultSync() {
 		if (this.syncPromise) {
 			return this.syncPromise;
@@ -487,6 +492,11 @@ export class UserMap implements UserMapInterface {
 		}
 	}
 
+	/**
+	 * Syncs the UserMap using the paginated sync method (multiple getMultipleAccounts calls with filters).
+	 * This method is more reliable when drift has many users.
+	 * @returns
+	 */
 	private async paginatedSync() {
 		if (this.syncPromise) {
 			return this.syncPromise;

package/src/userMap/userStatsMap.ts

@@ -15,6 +15,8 @@ import {
 	InsuranceFundStakeRecord,
 	BulkAccountLoader,
 	PollingUserStatsAccountSubscriber,
+	SyncConfig,
+	getUserStatsFilter,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 
@@ -27,6 +29,11 @@ export class UserStatsMap {
 	private userStatsMap = new Map<string, UserStats>();
 	private driftClient: DriftClient;
 	private bulkAccountLoader: BulkAccountLoader;
+	private decode;
+	private syncConfig: SyncConfig;
+
+	private syncPromise?: Promise<void>;
+	private syncPromiseResolver: () => void;
 
 	/**
 	 * Creates a new UserStatsMap instance.
@@ -34,7 +41,11 @@ export class UserStatsMap {
 	 * @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) {
+	constructor(
+		driftClient: DriftClient,
+		bulkAccountLoader?: BulkAccountLoader,
+		syncConfig?: SyncConfig
+	) {
 		this.driftClient = driftClient;
 		if (!bulkAccountLoader) {
 			bulkAccountLoader = new BulkAccountLoader(
@@ -44,6 +55,15 @@ export class UserStatsMap {
 			);
 		}
 		this.bulkAccountLoader = bulkAccountLoader;
+
+		this.syncConfig = syncConfig ?? {
+			type: 'default',
+		};
+
+		this.decode =
+			this.driftClient.program.account.userStats.coder.accounts.decodeUnchecked.bind(
+				this.driftClient.program.account.userStats.coder.accounts
+			);
 	}
 
 	public async subscribe(authorities: PublicKey[]) {
@@ -201,6 +221,19 @@ export class UserStatsMap {
 	 * You may want to get this list from UserMap in order to filter out idle users
 	 */
 	public async sync(authorities: PublicKey[]) {
+		if (this.syncConfig.type === 'default') {
+			return this.defaultSync(authorities);
+		} else {
+			return this.paginatedSync(authorities);
+		}
+	}
+
+	/**
+	 * Sync the UserStatsMap using the default sync method, which loads individual users into the bulkAccountLoader and
+	 * loads them. (bulkAccountLoader uses batch getMultipleAccounts)
+	 * @param authorities
+	 */
+	private async defaultSync(authorities: PublicKey[]) {
 		await Promise.all(
 			authorities.map((authority) =>
 				this.addUserStat(authority, undefined, true)
@@ -209,6 +242,120 @@ export class UserStatsMap {
 		await this.bulkAccountLoader.load();
 	}
 
+	/**
+	 * Sync the UserStatsMap using the paginated sync method, which uses multiple getMultipleAccounts calls (without RPC batching), and limits concurrency.
+	 * @param authorities
+	 */
+	private async paginatedSync(authorities: PublicKey[]) {
+		if (this.syncPromise) {
+			return this.syncPromise;
+		}
+
+		this.syncPromise = new Promise<void>((resolve) => {
+			this.syncPromiseResolver = resolve;
+		});
+
+		try {
+			let accountsToLoad = authorities;
+			if (authorities.length === 0) {
+				const accountsPrefetch =
+					await this.driftClient.connection.getProgramAccounts(
+						this.driftClient.program.programId,
+						{
+							dataSlice: { offset: 0, length: 0 },
+							filters: [getUserStatsFilter()],
+						}
+					);
+				accountsToLoad = accountsPrefetch.map((account) => account.pubkey);
+			}
+
+			const limitConcurrency = async (tasks, limit) => {
+				const executing = [];
+				const results = [];
+
+				for (let i = 0; i < tasks.length; i++) {
+					const executor = Promise.resolve().then(tasks[i]);
+					results.push(executor);
+
+					if (executing.length < limit) {
+						executing.push(executor);
+						executor.finally(() => {
+							const index = executing.indexOf(executor);
+							if (index > -1) {
+								executing.splice(index, 1);
+							}
+						});
+					} else {
+						await Promise.race(executing);
+					}
+				}
+
+				return Promise.all(results);
+			};
+
+			const programAccountBufferMap = new Set<string>();
+
+			// @ts-ignore
+			const chunkSize = this.syncConfig.chunkSize ?? 100;
+			const tasks = [];
+			for (let i = 0; i < accountsToLoad.length; i += chunkSize) {
+				const chunk = accountsToLoad.slice(i, i + chunkSize);
+				tasks.push(async () => {
+					const accountInfos =
+						await this.driftClient.connection.getMultipleAccountsInfoAndContext(
+							chunk,
+							{
+								commitment: this.driftClient.opts.commitment,
+							}
+						);
+
+					for (let j = 0; j < accountInfos.value.length; j += 1) {
+						const accountInfo = accountInfos.value[j];
+						if (accountInfo === null) continue;
+
+						const publicKeyString = chunk[j].toString();
+						if (!this.has(publicKeyString)) {
+							const buffer = Buffer.from(accountInfo.data);
+							const decodedUserStats = this.decode(
+								'UserStats',
+								buffer
+							) as UserStatsAccount;
+							programAccountBufferMap.add(
+								decodedUserStats.authority.toBase58()
+							);
+							this.addUserStat(
+								decodedUserStats.authority,
+								decodedUserStats,
+								false
+							);
+						}
+					}
+				});
+			}
+
+			// @ts-ignore
+			const concurrencyLimit = this.syncConfig.concurrencyLimit ?? 10;
+			await limitConcurrency(tasks, concurrencyLimit);
+
+			for (const [key] of this.userStatsMap.entries()) {
+				if (!programAccountBufferMap.has(key)) {
+					const user = this.get(key);
+					if (user) {
+						await user.unsubscribe();
+						this.userStatsMap.delete(key);
+					}
+				}
+			}
+		} catch (err) {
+			console.error(`Error in UserStatsMap.paginatedSync():`, err);
+		} finally {
+			if (this.syncPromiseResolver) {
+				this.syncPromiseResolver();
+			}
+			this.syncPromise = undefined;
+		}
+	}
+
 	public async unsubscribe() {
 		for (const [key, userStats] of this.userStatsMap.entries()) {
 			await userStats.unsubscribe();