@drift-labs/sdk 2.97.0-beta.22 → 2.97.0-beta.23

package/lib/{user.js → browser/user.js}

@@ -15,6 +15,7 @@ const oracles_1 = require("./math/oracles");
 const tiers_1 = require("./math/tiers");
 const strictOraclePrice_1 = require("./oracles/strictOraclePrice");
 const fuel_1 = require("./math/fuel");
+const grpcUserAccountSubscriber_1 = require("./accounts/grpcUserAccountSubscriber");
 class User {
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -23,7 +24,7 @@ class User {
         this._isSubscribed = val;
     }
     constructor(config) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this._isSubscribed = false;
         this.driftClient = config.driftClient;
         this.userAccountPublicKey = config.userAccountPublicKey;
@@ -33,11 +34,17 @@ class User {
         else if (((_b = config.accountSubscription) === null || _b === void 0 ? void 0 : _b.type) === 'custom') {
             this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
         }
+        else if (((_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.type) === 'grpc') {
+            this.accountSubscriber = new grpcUserAccountSubscriber_1.grpcUserAccountSubscriber(config.accountSubscription.grpcConfigs, config.driftClient.program, config.userAccountPublicKey, {
+                resubTimeoutMs: (_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.resubTimeoutMs,
+                logResubMessages: (_e = config.accountSubscription) === null || _e === void 0 ? void 0 : _e.logResubMessages,
+            });
+        }
         else {
             this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey, {
-                resubTimeoutMs: (_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.resubTimeoutMs,
-                logResubMessages: (_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.logResubMessages,
-            }, (_e = config.accountSubscription) === null || _e === void 0 ? void 0 : _e.commitment);
+                resubTimeoutMs: (_f = config.accountSubscription) === null || _f === void 0 ? void 0 : _f.resubTimeoutMs,
+                logResubMessages: (_g = config.accountSubscription) === null || _g === void 0 ? void 0 : _g.logResubMessages,
+            }, (_h = config.accountSubscription) === null || _h === void 0 ? void 0 : _h.commitment);
         }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
     }

package/lib/{userConfig.d.ts → browser/userConfig.d.ts}

@@ -1,13 +1,18 @@
 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;
     driftClient: DriftClient;
     userAccountPublicKey: PublicKey;
 };
 export type UserSubscriptionConfig = {
+    type: 'grpc';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    grpcConfigs: GrpcConfigs;
+} | {
     type: 'websocket';
     resubTimeoutMs?: number;
     logResubMessages?: boolean;

package/lib/{userMap → browser/userMap}/WebsocketSubscription.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { UserMap } from './userMap';
 import { UserAccount } from '../types';
 import { Commitment } from '@solana/web3.js';

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { UserMap } from './userMap';
+import { UserAccount } from '../types';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+export declare class grpcSubscription {
+    private grpcConfigs;
+    private userMap;
+    private skipInitialLoad;
+    private resubOpts?;
+    private includeIdle?;
+    private decodeFn;
+    private subscriber;
+    constructor({ grpcConfigs, userMap, skipInitialLoad, resubOpts, includeIdle, decodeFn, }: {
+        grpcConfigs: GrpcConfigs;
+        userMap: UserMap;
+        skipInitialLoad?: boolean;
+        resubOpts?: ResubOpts;
+        includeIdle?: boolean;
+        decodeFn: (name: string, data: Buffer) => UserAccount;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/browser/userMap/grpcSubscription.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcSubscription = void 0;
+const memcmp_1 = require("../memcmp");
+const grpcProgramAccountSubscriber_1 = require("../accounts/grpcProgramAccountSubscriber");
+class grpcSubscription {
+    constructor({ grpcConfigs, userMap, skipInitialLoad = false, resubOpts, includeIdle = false, decodeFn, }) {
+        this.userMap = userMap;
+        this.skipInitialLoad = skipInitialLoad;
+        this.resubOpts = resubOpts;
+        this.includeIdle = includeIdle || false;
+        this.decodeFn = decodeFn;
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            const filters = [(0, memcmp_1.getUserFilter)()];
+            if (!this.includeIdle) {
+                filters.push((0, memcmp_1.getNonIdleUserFilter)());
+            }
+            this.subscriber = new grpcProgramAccountSubscriber_1.grpcProgramAccountSubscriber(this.grpcConfigs, 'UserMap', 'User', this.userMap.driftClient.program, this.decodeFn, {
+                filters,
+            }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((accountId, account, context) => {
+            const userKey = accountId.toBase58();
+            this.userMap.updateUserAccount(userKey, account, context.slot);
+        });
+        if (!this.skipInitialLoad) {
+            await this.userMap.sync();
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+    }
+}
+exports.grpcSubscription = grpcSubscription;

package/lib/{userMap → browser/userMap}/userMap.js

@@ -9,6 +9,7 @@ const memcmp_1 = require("../memcmp");
 const WebsocketSubscription_1 = require("./WebsocketSubscription");
 const PollingSubscription_1 = require("./PollingSubscription");
 const user_1 = require("../decode/user");
+const grpcSubscription_1 = require("./grpcSubscription");
 const MAX_USER_ACCOUNT_SIZE_BYTES = 4376;
 class UserMap {
     /**
@@ -32,7 +33,10 @@ class UserMap {
             this.connection = this.driftClient.connection;
         }
         this.commitment =
-            (_a = config.subscriptionConfig.commitment) !== null && _a !== void 0 ? _a : this.driftClient.opts.commitment;
+            config.subscriptionConfig.type === 'websocket' ||
+                config.subscriptionConfig.type === 'polling'
+                ? (_a = config.subscriptionConfig.commitment) !== null && _a !== void 0 ? _a : this.driftClient.opts.commitment
+                : this.driftClient.opts.commitment;
         this.includeIdle = (_b = config.includeIdle) !== null && _b !== void 0 ? _b : false;
         this.disableSyncOnTotalAccountsChange =
             (_c = config.disableSyncOnTotalAccountsChange) !== null && _c !== void 0 ? _c : false;
@@ -52,6 +56,18 @@ class UserMap {
                 skipInitialLoad: config.skipInitialLoad,
             });
         }
+        else if (config.subscriptionConfig.type === 'grpc') {
+            this.subscription = new grpcSubscription_1.grpcSubscription({
+                userMap: this,
+                grpcConfigs: config.subscriptionConfig.grpcConfigs,
+                resubOpts: {
+                    resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+                    logResubMessages: config.subscriptionConfig.logResubMessages,
+                },
+                skipInitialLoad: config.skipInitialLoad,
+                decodeFn,
+            });
+        }
         else {
             this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
                 userMap: this,

package/lib/{userMap → browser/userMap}/userMapConfig.d.ts

@@ -1,5 +1,6 @@
 import { Commitment, Connection } from '@solana/web3.js';
 import { DriftClient } from '../driftClient';
+import { GrpcConfigs } from '../accounts/types';
 export type UserAccountFilterCriteria = {
     hasOpenOrders: boolean;
 };
@@ -17,6 +18,11 @@ export type UserMapConfig = {
         type: 'polling';
         frequency: number;
         commitment?: Commitment;
+    } | {
+        type: 'grpc';
+        grpcConfigs: GrpcConfigs;
+        resubTimeoutMs?: number;
+        logResubMessages?: boolean;
     } | {
         type: 'websocket';
         resubTimeoutMs?: number;

package/lib/{userStats.js → browser/userStats.js}

@@ -5,22 +5,29 @@ const web3_js_1 = require("@solana/web3.js");
 const pollingUserStatsAccountSubscriber_1 = require("./accounts/pollingUserStatsAccountSubscriber");
 const webSocketUserStatsAccountSubsriber_1 = require("./accounts/webSocketUserStatsAccountSubsriber");
 const pda_1 = require("./addresses/pda");
+const grpcUserStatsAccountSubscriber_1 = require("./accounts/grpcUserStatsAccountSubscriber");
 class UserStats {
     constructor(config) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this.driftClient = config.driftClient;
         this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
         if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
             this.accountSubscriber = new pollingUserStatsAccountSubscriber_1.PollingUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, config.accountSubscription.accountLoader);
         }
-        else if (((_b = config.accountSubscription) === null || _b === void 0 ? void 0 : _b.type) === 'websocket') {
-            this.accountSubscriber = new webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, {
+        else if (((_b = config.accountSubscription) === null || _b === void 0 ? void 0 : _b.type) === 'grpc') {
+            this.accountSubscriber = new grpcUserStatsAccountSubscriber_1.grpcUserStatsAccountSubscriber(config.accountSubscription.grpcConfigs, config.driftClient.program, config.userStatsAccountPublicKey, {
                 resubTimeoutMs: (_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.resubTimeoutMs,
                 logResubMessages: (_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.logResubMessages,
+            });
+        }
+        else if (((_e = config.accountSubscription) === null || _e === void 0 ? void 0 : _e.type) === 'websocket') {
+            this.accountSubscriber = new webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, {
+                resubTimeoutMs: (_f = config.accountSubscription) === null || _f === void 0 ? void 0 : _f.resubTimeoutMs,
+                logResubMessages: (_g = config.accountSubscription) === null || _g === void 0 ? void 0 : _g.logResubMessages,
             }, config.accountSubscription.commitment);
         }
         else {
-            throw new Error(`Unknown user stats account subscription type: ${(_e = config.accountSubscription) === null || _e === void 0 ? void 0 : _e.type}`);
+            throw new Error(`Unknown user stats account subscription type: ${(_h = config.accountSubscription) === null || _h === void 0 ? void 0 : _h.type}`);
         }
     }
     async subscribe(userStatsAccount) {

package/lib/{userStatsConfig.d.ts → browser/userStatsConfig.d.ts}

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

package/lib/node/accounts/basicUserAccountSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
+import { PublicKey } from '@solana/web3.js';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { UserAccount } from '../types';
+/**
+ * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+export declare class BasicUserAccountSubscriber implements UserAccountSubscriber {
+    isSubscribed: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    userAccountPublicKey: PublicKey;
+    callbackId?: string;
+    errorCallbackId?: string;
+    user: DataAndSlot<UserAccount>;
+    constructor(userAccountPublicKey: PublicKey, data?: UserAccount, slot?: number);
+    subscribe(_userAccount?: UserAccount): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+    updateData(userAccount: UserAccount, slot: number): void;
+}

package/lib/node/accounts/basicUserAccountSubscriber.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicUserAccountSubscriber = void 0;
+const events_1 = require("events");
+/**
+ * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+class BasicUserAccountSubscriber {
+    constructor(userAccountPublicKey, data, slot) {
+        this.isSubscribed = true;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
+        this.user = { data, slot };
+    }
+    async subscribe(_userAccount) {
+        return true;
+    }
+    async addToAccountLoader() { }
+    async fetch() { }
+    doesAccountExist() {
+        return this.user !== undefined;
+    }
+    async unsubscribe() { }
+    assertIsSubscribed() { }
+    getUserAccountAndSlot() {
+        return this.user;
+    }
+    updateData(userAccount, slot) {
+        var _a;
+        if (!this.user || slot >= ((_a = this.user.slot) !== null && _a !== void 0 ? _a : 0)) {
+            this.user = { data: userAccount, slot };
+            this.eventEmitter.emit('userAccountUpdate', userAccount);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.BasicUserAccountSubscriber = BasicUserAccountSubscriber;

package/lib/node/accounts/bulkAccountLoader.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { BufferAndSlot } from './types';
+import { Connection } from '../bankrun/bankrunConnection';
+export type AccountToLoad = {
+    publicKey: PublicKey;
+    callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
+};
+export declare class BulkAccountLoader {
+    connection: Connection;
+    commitment: Commitment;
+    pollingFrequency: number;
+    accountsToLoad: Map<string, AccountToLoad>;
+    bufferAndSlotMap: Map<string, BufferAndSlot>;
+    errorCallbacks: Map<string, (e: any) => void>;
+    intervalId?: ReturnType<typeof setTimeout>;
+    loadPromise?: Promise<void>;
+    loadPromiseResolver: () => void;
+    lastTimeLoadingPromiseCleared: number;
+    mostRecentSlot: number;
+    constructor(connection: Connection, commitment: Commitment, pollingFrequency: number);
+    addAccount(publicKey: PublicKey, callback: (buffer: Buffer, slot: number) => void): Promise<string>;
+    removeAccount(publicKey: PublicKey, callbackId: string): void;
+    addErrorCallbacks(callback: (error: Error) => void): string;
+    removeErrorCallbacks(callbackId: string): void;
+    chunks<T>(array: readonly T[], size: number): T[][];
+    load(): Promise<void>;
+    loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void>;
+    handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer, slot: number): void;
+    getBufferAndSlot(publicKey: PublicKey): BufferAndSlot | undefined;
+    getSlot(): number;
+    startPolling(): void;
+    stopPolling(): void;
+    log(msg: string): void;
+    updatePollingFrequency(pollingFrequency: number): void;
+}

package/lib/node/accounts/bulkAccountLoader.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkAccountLoader = void 0;
+const uuid_1 = require("uuid");
+const promiseTimeout_1 = require("../util/promiseTimeout");
+const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+const oneMinute = 60 * 1000;
+class BulkAccountLoader {
+    constructor(connection, commitment, pollingFrequency) {
+        this.accountsToLoad = new Map();
+        this.bufferAndSlotMap = new Map();
+        this.errorCallbacks = new Map();
+        this.lastTimeLoadingPromiseCleared = Date.now();
+        this.mostRecentSlot = 0;
+        this.connection = connection;
+        this.commitment = commitment;
+        this.pollingFrequency = pollingFrequency;
+    }
+    async addAccount(publicKey, callback) {
+        if (!publicKey) {
+            console.trace(`Caught adding blank publickey to bulkAccountLoader`);
+        }
+        const existingSize = this.accountsToLoad.size;
+        const callbackId = (0, uuid_1.v4)();
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.set(callbackId, callback);
+        }
+        else {
+            const callbacks = new Map();
+            callbacks.set(callbackId, callback);
+            const newAccountToLoad = {
+                publicKey,
+                callbacks,
+            };
+            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
+        }
+        if (existingSize === 0) {
+            this.startPolling();
+        }
+        // resolve the current loadPromise in case client wants to call load
+        await this.loadPromise;
+        return callbackId;
+    }
+    removeAccount(publicKey, callbackId) {
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.delete(callbackId);
+            if (existingAccountToLoad.callbacks.size === 0) {
+                this.bufferAndSlotMap.delete(publicKey.toString());
+                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
+            }
+        }
+        if (this.accountsToLoad.size === 0) {
+            this.stopPolling();
+        }
+    }
+    addErrorCallbacks(callback) {
+        const callbackId = (0, uuid_1.v4)();
+        this.errorCallbacks.set(callbackId, callback);
+        return callbackId;
+    }
+    removeErrorCallbacks(callbackId) {
+        this.errorCallbacks.delete(callbackId);
+    }
+    chunks(array, size) {
+        return new Array(Math.ceil(array.length / size))
+            .fill(null)
+            .map((_, index) => index * size)
+            .map((begin) => array.slice(begin, begin + size));
+    }
+    async load() {
+        if (this.loadPromise) {
+            const now = Date.now();
+            if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+                this.loadPromise = undefined;
+            }
+            else {
+                return this.loadPromise;
+            }
+        }
+        this.loadPromise = new Promise((resolver) => {
+            this.loadPromiseResolver = resolver;
+        });
+        this.lastTimeLoadingPromiseCleared = Date.now();
+        try {
+            const chunks = this.chunks(this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE), 10);
+            await Promise.all(chunks.map((chunk) => {
+                return this.loadChunk(chunk);
+            }));
+        }
+        catch (e) {
+            console.error(`Error in bulkAccountLoader.load()`);
+            console.error(e);
+            for (const [_, callback] of this.errorCallbacks) {
+                callback(e);
+            }
+        }
+        finally {
+            this.loadPromiseResolver();
+            this.loadPromise = undefined;
+        }
+    }
+    async loadChunk(accountsToLoadChunks) {
+        if (accountsToLoadChunks.length === 0) {
+            return;
+        }
+        const requests = new Array();
+        for (const accountsToLoadChunk of accountsToLoadChunks) {
+            const args = [
+                accountsToLoadChunk
+                    .filter((accountToLoad) => accountToLoad.callbacks.size > 0)
+                    .map((accountToLoad) => {
+                    return accountToLoad.publicKey.toBase58();
+                }),
+                { commitment: this.commitment },
+            ];
+            requests.push({
+                methodName: 'getMultipleAccounts',
+                args,
+            });
+        }
+        const rpcResponses = await (0, promiseTimeout_1.promiseTimeout)(
+        // @ts-ignore
+        this.connection._rpcBatchRequest(requests), 10 * 1000 // 30 second timeout
+        );
+        if (rpcResponses === null) {
+            this.log('request to rpc timed out');
+            return;
+        }
+        rpcResponses.forEach((rpcResponse, i) => {
+            if (!rpcResponse.result) {
+                console.error('rpc response missing result:');
+                console.log(JSON.stringify(rpcResponse));
+                return;
+            }
+            const newSlot = rpcResponse.result.context.slot;
+            if (newSlot > this.mostRecentSlot) {
+                this.mostRecentSlot = newSlot;
+            }
+            const accountsToLoad = accountsToLoadChunks[i];
+            accountsToLoad.forEach((accountToLoad, j) => {
+                if (accountToLoad.callbacks.size === 0) {
+                    return;
+                }
+                const key = accountToLoad.publicKey.toBase58();
+                const oldRPCResponse = this.bufferAndSlotMap.get(key);
+                if (oldRPCResponse && newSlot < oldRPCResponse.slot) {
+                    return;
+                }
+                let newBuffer = undefined;
+                if (rpcResponse.result.value[j]) {
+                    const raw = rpcResponse.result.value[j].data[0];
+                    const dataType = rpcResponse.result.value[j].data[1];
+                    newBuffer = Buffer.from(raw, dataType);
+                }
+                if (!oldRPCResponse) {
+                    this.bufferAndSlotMap.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                    return;
+                }
+                const oldBuffer = oldRPCResponse.buffer;
+                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.bufferAndSlotMap.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                }
+            });
+        });
+    }
+    handleAccountCallbacks(accountToLoad, buffer, slot) {
+        for (const [_, callback] of accountToLoad.callbacks) {
+            try {
+                callback(buffer, slot);
+            }
+            catch (e) {
+                console.log('Bulk account load: error in account callback');
+                console.log('accounto to load', accountToLoad.publicKey.toString());
+                console.log('buffer', buffer.toString('base64'));
+                for (const callback of accountToLoad.callbacks.values()) {
+                    console.log('account to load cb', callback);
+                }
+                throw e;
+            }
+        }
+    }
+    getBufferAndSlot(publicKey) {
+        return this.bufferAndSlotMap.get(publicKey.toString());
+    }
+    getSlot() {
+        return this.mostRecentSlot;
+    }
+    startPolling() {
+        if (this.intervalId) {
+            return;
+        }
+        if (this.pollingFrequency !== 0)
+            this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+    }
+    stopPolling() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    log(msg) {
+        console.log(msg);
+    }
+    updatePollingFrequency(pollingFrequency) {
+        this.stopPolling();
+        this.pollingFrequency = pollingFrequency;
+        if (this.accountsToLoad.size > 0) {
+            this.startPolling();
+        }
+    }
+}
+exports.BulkAccountLoader = BulkAccountLoader;

package/lib/node/accounts/bulkUserStatsSubscription.d.ts

@@ -0,0 +1,7 @@
+import { UserStats } from '../userStats';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+export declare function bulkPollingUserStatsSubscribe(userStats: UserStats[], accountLoader: BulkAccountLoader): Promise<void>;

package/lib/node/accounts/bulkUserStatsSubscription.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkPollingUserStatsSubscribe = void 0;
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+async function bulkPollingUserStatsSubscribe(userStats, accountLoader) {
+    if (userStats.length === 0) {
+        await accountLoader.load();
+        return;
+    }
+    await Promise.all(userStats.map((userStat) => {
+        return userStat.accountSubscriber.addToAccountLoader();
+    }));
+    await accountLoader.load();
+    await Promise.all(userStats.map(async (userStat) => {
+        return userStat.subscribe();
+    }));
+}
+exports.bulkPollingUserStatsSubscribe = bulkPollingUserStatsSubscribe;

package/lib/node/accounts/bulkUserSubscription.d.ts

@@ -0,0 +1,7 @@
+import { User } from '../user';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param users
+ * @param accountLoader
+ */
+export declare function bulkPollingUserSubscribe(users: User[], accountLoader: BulkAccountLoader): Promise<void>;

package/lib/node/accounts/bulkUserSubscription.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkPollingUserSubscribe = void 0;
+/**
+ * @param users
+ * @param accountLoader
+ */
+async function bulkPollingUserSubscribe(users, accountLoader) {
+    if (users.length === 0) {
+        await accountLoader.load();
+        return;
+    }
+    await Promise.all(users.map((user) => {
+        return user.accountSubscriber.addToAccountLoader();
+    }));
+    await accountLoader.load();
+    await Promise.all(users.map(async (user) => {
+        return user.subscribe();
+    }));
+}
+exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;

package/lib/node/accounts/fetch.d.ts

@@ -0,0 +1,6 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { UserAccount, UserStatsAccount } from '../types';
+import { Program } from '@coral-xyz/anchor';
+export declare function fetchUserAccounts(connection: Connection, program: Program, authority: PublicKey, limit?: number): Promise<(UserAccount | undefined)[]>;
+export declare function fetchUserAccountsUsingKeys(connection: Connection, program: Program, userAccountPublicKeys: PublicKey[]): Promise<(UserAccount | undefined)[]>;
+export declare function fetchUserStatsAccount(connection: Connection, program: Program, authority: PublicKey): Promise<UserStatsAccount | undefined>;