@drift-labs/sdk-browser 2.104.0-beta.21

package/README.md

@@ -0,0 +1,276 @@
+<div align="center">
+  <img height="120x" src="https://uploads-ssl.webflow.com/611580035ad59b20437eb024/616f97a42f5637c4517d0193_Logo%20(1)%20(1).png" />
+
+  <h1 style="margin-top:20px;">Drift Protocol v2</h1>
+
+  <p>
+    <a href="https://www.npmjs.com/package/@drift-labs/sdk"><img alt="SDK npm package" src="https://img.shields.io/npm/v/@drift-labs/sdk" /></a>
+    <a href="https://drift-labs.github.io/protocol-v2/sdk/"><img alt="Docs" src="https://img.shields.io/badge/docs-tutorials-blueviolet" /></a>
+    <a href="https://discord.com/channels/849494028176588802/878700556904980500"><img alt="Discord Chat" src="https://img.shields.io/discord/889577356681945098?color=blueviolet" /></a>
+    <a href="https://opensource.org/licenses/Apache-2.0"><img alt="License" src="https://img.shields.io/github/license/project-serum/anchor?color=blueviolet" /></a>
+  </p>
+</div>
+
+## Installation
+
+```
+npm i @drift-labs/sdk
+```
+
+## Getting Started
+
+*Start here if you're integrating with Drift!*
+
+- [Drift v2-teacher + API Docs](https://drift-labs.github.io/v2-teacher/)
+	- Docs and examples for using the SDK in Typescript and Python
+	- Useful concepts and examples when integrating Drift
+	- Docs for Drift's "Data API"
+- [Typescript API docs](https://drift-labs.github.io/protocol-v2/sdk/)
+	- JSDoc automated documentation for the Drift v2 Typescript SDK
+- [Drift docs](https://docs.drift.trade/)
+	- Comprehensive universal docs for Drift
+
+---
+
+The below is a light overview of using Solana and Drift's typescript sdk. If you want comprehensive docs with examples of how to integrate with Drift you should use the [v2-teacher docs](https://drift-labs.github.io/v2-teacher/).
+
+### Setting up a wallet for your program
+
+```bash
+# Generate a keypair
+solana-keygen new
+
+# Get the pubkey for the new wallet (You will need to send USDC to this address to Deposit into Drift (only on mainnet - devnet has a faucet for USDC))
+solana address
+
+# Put the private key into your .env to be used by your bot
+cd {projectLocation}
+echo BOT_PRIVATE_KEY=`cat ~/.config/solana/id.json` >> .env
+```
+
+## Concepts
+
+### BN / Precision
+
+The Drift SDK uses BigNum (BN), using [this package](https://github.com/indutny/bn.js/), to represent numerical values. This is because Solana tokens tend to use levels of precision which are too precise for standard Javascript floating point numbers to handle. All numbers in BN are represented as integers, and we will often denote the `precision` of the number so that it can be converted back down to a regular number.
+
+```bash
+Example:
+a BigNum: 10,500,000, with precision 10^6, is equal to 10.5 because 10,500,000 / 10^6 = 10.5.
+```
+
+The Drift SDK uses some common precisions, which are available as constants to import from the SDK.
+
+| Precision Name        | Value |
+| --------------------- | ----- |
+| FUNDING_RATE_BUFFER   | 10^3  |
+| QUOTE_PRECISION       | 10^6  |
+| PEG_PRECISION         | 10^6  |
+| PRICE_PRECISION       | 10^6  |
+| AMM_RESERVE_PRECISION | 10^9  |
+| BASE_PRECISION        | 10^9  |
+
+**Important Note for BigNum division**
+
+Because BN only supports integers, you need to be conscious of the numbers you are using when dividing. BN will return the floor when using the regular division function; if you want to get the exact division, you need to add the modulus of the two numbers as well. There is a helper function `convertToNumber` in the SDK which will do this for you.
+
+```typescript
+import {convertToNumber} from @drift-labs/sdk
+
+// Gets the floor value
+new BN(10500).div(new BN(1000)).toNumber(); // = 10
+
+// Gets the exact value
+new BN(10500).div(new BN(1000)).toNumber() + BN(10500).mod(new BN(1000)).toNumber(); // = 10.5
+
+// Also gets the exact value
+convertToNumber(new BN(10500), new BN(1000)); // = 10.5
+```
+
+## Examples
+
+### Setting up an account and making a trade
+
+```typescript
+import * as anchor from '@coral-xyz/anchor';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { getAssociatedTokenAddress, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import {
+	calculateReservePrice,
+	DriftClient,
+	User,
+	initialize,
+	PositionDirection,
+	convertToNumber,
+	calculateTradeSlippage,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+	Wallet,
+	PerpMarkets,
+	BASE_PRECISION,
+	getMarketOrderParams,
+	BulkAccountLoader,
+	BN,
+	calculateBidAskPrice,
+	getMarketsAndOraclesForSubscription,
+	calculateEstimatedPerpEntryPrice,
+} from '../sdk';
+
+export const getTokenAddress = (
+	mintAddress: string,
+	userPubKey: string
+): Promise<PublicKey> => {
+	return getAssociatedTokenAddress(
+		new PublicKey(mintAddress),
+		new PublicKey(userPubKey)
+	);
+};
+
+const main = async () => {
+	const env = 'devnet';
+	// const env = 'mainnet-beta';
+
+	// Initialize Drift SDK
+	const sdkConfig = initialize({ env });
+
+	// Set up the Wallet and Provider
+	if (!process.env.ANCHOR_WALLET) {
+		throw new Error('ANCHOR_WALLET env var must be set.');
+	}
+
+	if (!process.env.ANCHOR_PROVIDER_URL) {
+		throw new Error('ANCHOR_PROVIDER_URL env var must be set.');
+	}
+
+	const provider = anchor.AnchorProvider.local(
+		process.env.ANCHOR_PROVIDER_URL,
+		{
+			preflightCommitment: 'confirmed',
+			skipPreflight: false,
+			commitment: 'confirmed',
+		}
+	);
+	// Check SOL Balance
+	const lamportsBalance = await provider.connection.getBalance(
+		provider.wallet.publicKey
+	);
+	console.log(
+		provider.wallet.publicKey.toString(),
+		env,
+		'SOL balance:',
+		lamportsBalance / 10 ** 9
+	);
+
+	// Misc. other things to set up
+	const usdcTokenAddress = await getTokenAddress(
+		sdkConfig.USDC_MINT_ADDRESS,
+		provider.wallet.publicKey.toString()
+	);
+
+	// Set up the Drift Client
+	const driftPublicKey = new PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
+	const bulkAccountLoader = new BulkAccountLoader(
+		provider.connection,
+		'confirmed',
+		1000
+	);
+	const driftClient = new DriftClient({
+		connection: provider.connection,
+		wallet: provider.wallet,
+		programID: driftPublicKey,
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
+	await driftClient.subscribe();
+
+	console.log('subscribed to driftClient');
+
+	// Set up user client
+	const user = new User({
+		driftClient: driftClient,
+		userAccountPublicKey: await driftClient.getUserAccountPublicKey(),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
+
+	//// Check if user account exists for the current wallet
+	const userAccountExists = await user.exists();
+
+	if (!userAccountExists) {
+		console.log(
+			'initializing to',
+			env,
+			' drift account for',
+			provider.wallet.publicKey.toString()
+		);
+
+		//// Create a Drift V2 account by Depositing some USDC ($10,000 in this case)
+		const depositAmount = new BN(10000).mul(QUOTE_PRECISION);
+		await driftClient.initializeUserAccountAndDepositCollateral(
+			depositAmount,
+			await getTokenAddress(
+				usdcTokenAddress.toString(),
+				provider.wallet.publicKey.toString()
+			)
+		);
+	}
+
+	await user.subscribe();
+
+	// Get current price
+	const solMarketInfo = PerpMarkets[env].find(
+		(market) => market.baseAssetSymbol === 'SOL'
+	);
+
+	const marketIndex = solMarketInfo.marketIndex;
+
+	// Get vAMM bid and ask price
+	const [bid, ask] = calculateBidAskPrice(
+		driftClient.getPerpMarketAccount(marketIndex).amm,
+		driftClient.getOracleDataForPerpMarket(marketIndex)
+	);
+
+	const formattedBidPrice = convertToNumber(bid, PRICE_PRECISION);
+	const formattedAskPrice = convertToNumber(ask, PRICE_PRECISION);
+
+	console.log(
+		env,
+		`vAMM bid: $${formattedBidPrice} and ask: $${formattedAskPrice}`
+	);
+
+	const solMarketAccount = driftClient.getPerpMarketAccount(
+		solMarketInfo.marketIndex
+	);
+	console.log(env, `Placing a 1 SOL-PERP LONG order`);
+
+	const txSig = await driftClient.placePerpOrder(
+		getMarketOrderParams({
+			baseAssetAmount: new BN(1).mul(BASE_PRECISION),
+			direction: PositionDirection.LONG,
+			marketIndex: solMarketAccount.marketIndex,
+		})
+	);
+	console.log(
+		env,
+		`Placed a 1 SOL-PERP LONG order. Tranaction signature: ${txSig}`
+	);
+};
+
+main();
+```
+
+## License
+
+Drift Protocol v2 is licensed under [Apache 2.0](./LICENSE).
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Drift SDK by you, as defined in the Apache-2.0 license, shall be
+licensed as above, without any additional terms or conditions.
+
+

package/VERSION

@@ -0,0 +1 @@
+2.104.0-beta.21

package/get_events.ts

@@ -0,0 +1,47 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import {
+  configs,
+  DriftClient,
+  Wallet,
+} from "@drift-labs/sdk";
+
+
+async function main() {
+
+  const driftConfig = configs['mainnet-beta'];
+  const connection = new Connection('https://api.mainnet-beta.solana.com');
+
+  const driftClient = new DriftClient({
+    connection: connection,
+    wallet: new Wallet(new Keypair()),
+    programID: new PublicKey(driftConfig.DRIFT_PROGRAM_ID),
+    userStats: true,
+    env: 'mainnet-beta',
+  });
+  console.log(`driftClientSubscribed: ${await driftClient.subscribe()}`);
+
+  const txHash = "3gvGQufckXGHrFDv4dNWEXuXKRMy3NZkKHMyFrAhLoYScaXXTGCp9vq58kWkfyJ8oDYZrz4bTyGayjUy9PKigeLS";
+
+  const tx = await driftClient.connection.getParsedTransaction(txHash, {
+    commitment: "confirmed",
+    maxSupportedTransactionVersion: 0,
+  });
+
+  let logIdx = 0;
+  // @ts-ignore
+  for (const event of driftClient.program._events._eventParser.parseLogs(tx!.meta!.logMessages)) {
+    console.log("----------------------------------------");
+    console.log(`Log ${logIdx++}`);
+    console.log("----------------------------------------");
+    console.log(`${JSON.stringify(event, null, 2)}`);
+  }
+
+  console.log("========================================");
+  console.log("Raw transaction logs");
+  console.log("========================================");
+  console.log(JSON.stringify(tx!.meta!.logMessages, null, 2));
+
+  process.exit(0);
+}
+
+main().catch(console.error);

package/lib/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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>;