@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/my-script/multiConnections.ts

@@ -0,0 +1,119 @@
+import * as anchor from '@project-serum/anchor';
+import { PublicKey, clusterApiUrl } from '@solana/web3.js';
+
+import {
+	initialize,
+	BulkAccountLoader,
+	EventSubscriber,
+	DevnetMarkets,
+	ClearingHouse,
+} from '..';
+import { printUserStats } from './utils';
+
+require('dotenv').config();
+
+
+async function main(provider: anchor.AnchorProvider) {
+	const connection = provider.connection;
+	const config = initialize({ env: 'devnet' });
+	const clearingHousePublicKey = new PublicKey(
+		config.CLEARING_HOUSE_PROGRAM_ID
+	);
+
+	const bulkAccountLoader = new BulkAccountLoader(
+		connection,
+		'confirmed',
+		1000
+	);
+	const clearingHouse = new ClearingHouse({
+		connection,
+		wallet: provider.wallet,
+		programID: clearingHousePublicKey,
+		env: 'devnet',
+		// accountSubscription: {
+		// 	type: 'websocket',
+		// }
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
+
+	console.log(`clearingHouseProgramID: ${clearingHousePublicKey}`);
+	console.log(
+		`provider.wallet:        ${provider.wallet.publicKey.toBase58()}`
+	);
+
+	const eventSubscriber = new EventSubscriber(
+		connection,
+		clearingHouse.program,
+		{
+			maxTx: 8192,
+			maxEventsPerType: 4096,
+			orderBy: 'blockchain',
+			orderDir: 'desc',
+			commitment: 'confirmed',
+			logProviderConfig: {
+				type: 'websocket',
+			},
+		}
+	);
+
+	if (!(await clearingHouse.getUser().exists())) {
+		console.error(
+			`ClearingHouseUser for ${provider.wallet.publicKey} does not exist`
+		);
+		console.info(`Creating ClearingHouseUser for ${provider.wallet.publicKey}`);
+		const [txSig] = await clearingHouse.initializeUserAccount();
+		console.log(`Initialized user account in transaction: ${txSig}`);
+	}
+
+	if (!(await clearingHouse.subscribe())) {
+		throw new Error('fail clearingHouse.subscribe');
+	}
+	if (!(await clearingHouse.accountSubscriber.subscribe())) {
+		throw new Error('fail clearingHouse.accountSubscriber.subscribe');
+	}
+	if (!eventSubscriber.subscribe()) {
+		throw new Error('fail eventSubscriber.subscribe');
+	}
+
+	const chUser = clearingHouse.getUser();
+	const chUserAccount = clearingHouse.getUserAccount();
+	console.log(`chUserAcc.authority:    ${chUserAccount!.authority.toBase58()}`);
+	console.log(
+		`  chUserAccount pubkey: ${chUser.userAccountPublicKey.toBase58()}`
+	);
+
+	const keyToSymbol = new Map<string, string>();
+	const marketIndexToSymbol = new Map<number, string>();
+	for (const market of DevnetMarkets) {
+		keyToSymbol.set(market.oracle.toBase58(), market.baseAssetSymbol);
+		marketIndexToSymbol.set(market.marketIndex.toNumber(), market.symbol);
+	}
+
+	const run = async () => {
+		await clearingHouse.fetchAccounts();
+		await chUser.fetchAccounts();
+		printUserStats(chUserAccount!, marketIndexToSymbol);
+	};
+	await run();
+	setInterval(run, 1000);
+}
+
+try {
+	if (!process.env.ANCHOR_WALLET) {
+		throw new Error('ANCHOR_WALLET must be set.');
+	}
+	main(
+		anchor.AnchorProvider.local(clusterApiUrl('devnet'), {
+			// anchor.AnchorProvider.local('https://devnet.genesysgo.net', {
+			preflightCommitment: 'confirmed',
+			skipPreflight: false,
+			commitment: 'confirmed',
+		})
+	);
+	// anchor.AnchorProvider.local('https://psytrbhymqlkfrhudd.dev.genesysgo.net:8899/');
+} catch (e) {
+	console.error(e);
+}

package/my-script/test-regex.ts

@@ -0,0 +1,11 @@
+try {
+    // const msg = 'Program 65sz7dRiWDRPZjiRxcTxPM7AE6VK4Nag9HEK6oBJXhJn failed: custom program error: 0x179e'
+    const msg = 'Program log: AnchorError occurred. Error Code: OrderDoesNotExist. Error Number: 6046. Error Message: Order does not exist.';
+    const code = msg.match(
+        /Program log: AnchorError occurred. Error Code: ([0-9,a-z,A-Z]+). Error Number/
+    );
+    console.log(code[1]);
+} catch (e) {
+    console.log("nothing");
+    // no problem if couldn't match error code
+}

package/my-script/utils.ts

@@ -0,0 +1,52 @@
+import {
+    ClearingHouse,
+    UserAccount,
+} from '..';
+
+export function printUserStats(chUserAccount: UserAccount, marketIndexToSymbol: Map<number, string>) {
+
+    console.log("");
+    console.log(`${new Date(Date.now())}`);
+    console.log("Open positions:");
+    let openPositions = 0;
+    for (const p of chUserAccount!.positions) {
+        if (p.baseAssetAmount.isZero()) {
+            continue;
+        }
+        console.log(` [${marketIndexToSymbol.get(p.marketIndex.toNumber())}]`);
+        console.log(` . baseAssetAmount:  ${p.baseAssetAmount.toString()}`);
+        console.log(` . quoteAssetAmount: ${p.quoteAssetAmount.toString()}`);
+        console.log(` . quoteEntryAmount: ${p.quoteEntryAmount.toString()}`);
+        console.log(` . lastCumulativeFundingRate: ${p.lastCumulativeFundingRate.toString()}`);
+        console.log(` . openOrders: ${p.openOrders}`);
+        console.log(` . openBids: ${p.openBids.toString()}`);
+        console.log(` . openAsks: ${p.openAsks.toString()}`);
+        openPositions++;
+    }
+    console.log(`count: ${openPositions}`);
+
+    let openOrders = 0;
+    console.log("");
+    console.log("Open orders:");
+    for (const o of chUserAccount!.orders) {
+        if (o.baseAssetAmount.isZero()) {
+            continue;
+        }
+        console.log(` . [OrderId: ${o.orderId.toString()}, ${JSON.stringify(o.status)} ${JSON.stringify(o.direction)}, mktIdx: ${o.marketIndex.toString()}]: ${o.baseAssetAmountFilled.toString()}/${o.baseAssetAmount.toString()}`);
+        openOrders++;
+    }
+    console.log(`count: ${openOrders}`);
+
+    return;
+}
+
+export async function cancelOpenOrders(clearingHouse: ClearingHouse, chUserAccount: UserAccount) {
+    for (const o of chUserAccount!.orders) {
+        if (o.baseAssetAmount.isZero()) {
+            continue;
+        }
+
+        const tx = await clearingHouse.cancelOrder(o.orderId);
+        console.log(`Canceled orderID ${o.orderId.toString()} on market ${o.marketIndex.toString()}, tx: ${tx}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.24",
+	"version": "0.2.0-master.26",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.js

@@ -0,0 +1,249 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.BulkAccountLoader = void 0;
+var uuid_1 = require("uuid");
+var promiseTimeout_1 = require("../util/promiseTimeout");
+var GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+var oneMinute = 60 * 1000;
+var BulkAccountLoader = /** @class */ (function () {
+    function BulkAccountLoader(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;
+    }
+    BulkAccountLoader.prototype.addAccount = function (publicKey, callback) {
+        var existingSize = this.accountsToLoad.size;
+        var callbackId = (0, uuid_1.v4)();
+        var existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.set(callbackId, callback);
+        }
+        else {
+            var callbacks = new Map();
+            callbacks.set(callbackId, callback);
+            var newAccountToLoad = {
+                publicKey: publicKey,
+                callbacks: callbacks
+            };
+            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
+        }
+        if (existingSize === 0) {
+            this.startPolling();
+        }
+        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
+        this.loadPromise = undefined;
+        return callbackId;
+    };
+    BulkAccountLoader.prototype.removeAccount = function (publicKey, callbackId) {
+        var existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks["delete"](callbackId);
+            if (existingAccountToLoad.callbacks.size === 0) {
+                this.accountsToLoad["delete"](existingAccountToLoad.publicKey.toString());
+            }
+        }
+        if (this.accountsToLoad.size === 0) {
+            this.stopPolling();
+        }
+    };
+    BulkAccountLoader.prototype.addErrorCallbacks = function (callback) {
+        var callbackId = (0, uuid_1.v4)();
+        this.errorCallbacks.set(callbackId, callback);
+        return callbackId;
+    };
+    BulkAccountLoader.prototype.removeErrorCallbacks = function (callbackId) {
+        this.errorCallbacks["delete"](callbackId);
+    };
+    BulkAccountLoader.prototype.chunks = function (array, size) {
+        return new Array(Math.ceil(array.length / size))
+            .fill(null)
+            .map(function (_, index) { return index * size; })
+            .map(function (begin) { return array.slice(begin, begin + size); });
+    };
+    BulkAccountLoader.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, chunks, e_1, _i, _a, _b, _1, callback;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.loadPromise) {
+                            now = Date.now();
+                            if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+                                this.loadPromise = undefined;
+                            }
+                            else {
+                                return [2 /*return*/, this.loadPromise];
+                            }
+                        }
+                        this.loadPromise = new Promise(function (resolver) {
+                            _this.loadPromiseResolver = resolver;
+                        });
+                        this.lastTimeLoadingPromiseCleared = Date.now();
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, 4, 5]);
+                        chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+                        return [4 /*yield*/, Promise.all(chunks.map(function (chunk) {
+                                return _this.loadChunk(chunk);
+                            }))];
+                    case 2:
+                        _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        e_1 = _c.sent();
+                        console.error("Error in bulkAccountLoader.load()");
+                        console.error(e_1);
+                        for (_i = 0, _a = this.errorCallbacks; _i < _a.length; _i++) {
+                            _b = _a[_i], _1 = _b[0], callback = _b[1];
+                            callback(e_1);
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this.loadPromiseResolver();
+                        this.loadPromise = undefined;
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BulkAccountLoader.prototype.loadChunk = function (accountsToLoad) {
+        return __awaiter(this, void 0, void 0, function () {
+            var args, rpcResponse, newSlot, i, accountToLoad, key, oldRPCResponse, newBuffer, raw, dataType, oldBuffer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (accountsToLoad.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        args = [
+                            accountsToLoad.map(function (accountToLoad) {
+                                return accountToLoad.publicKey.toBase58();
+                            }),
+                            { commitment: this.commitment },
+                        ];
+                        return [4 /*yield*/, (0, promiseTimeout_1.promiseTimeout)(
+                            // @ts-ignore
+                            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
+                            )];
+                    case 1:
+                        rpcResponse = _a.sent();
+                        if (rpcResponse === null) {
+                            this.log('request to rpc timed out');
+                            return [2 /*return*/];
+                        }
+                        newSlot = rpcResponse.result.context.slot;
+                        if (newSlot > this.mostRecentSlot) {
+                            this.mostRecentSlot = newSlot;
+                        }
+                        for (i in accountsToLoad) {
+                            accountToLoad = accountsToLoad[i];
+                            key = accountToLoad.publicKey.toString();
+                            oldRPCResponse = this.bufferAndSlotMap.get(key);
+                            newBuffer = undefined;
+                            if (rpcResponse.result.value[i]) {
+                                raw = rpcResponse.result.value[i].data[0];
+                                dataType = rpcResponse.result.value[i].data[1];
+                                newBuffer = Buffer.from(raw, dataType);
+                            }
+                            if (!oldRPCResponse) {
+                                this.bufferAndSlotMap.set(key, {
+                                    slot: newSlot,
+                                    buffer: newBuffer
+                                });
+                                this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                                continue;
+                            }
+                            if (newSlot <= oldRPCResponse.slot) {
+                                continue;
+                            }
+                            oldBuffer = oldRPCResponse.buffer;
+                            if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                                this.bufferAndSlotMap.set(key, {
+                                    slot: newSlot,
+                                    buffer: newBuffer
+                                });
+                                this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                            }
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BulkAccountLoader.prototype.handleAccountCallbacks = function (accountToLoad, buffer, slot) {
+        for (var _i = 0, _a = accountToLoad.callbacks; _i < _a.length; _i++) {
+            var _b = _a[_i], _2 = _b[0], callback = _b[1];
+            callback(buffer, slot);
+        }
+    };
+    BulkAccountLoader.prototype.getBufferAndSlot = function (publicKey) {
+        return this.bufferAndSlotMap.get(publicKey.toString());
+    };
+    BulkAccountLoader.prototype.startPolling = function () {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+    };
+    BulkAccountLoader.prototype.stopPolling = function () {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    };
+    BulkAccountLoader.prototype.log = function (msg) {
+        console.log(msg);
+    };
+    BulkAccountLoader.prototype.updatePollingFrequency = function (pollingFrequency) {
+        this.stopPolling();
+        this.pollingFrequency = pollingFrequency;
+        if (this.accountsToLoad.size > 0) {
+            this.startPolling();
+        }
+    };
+    return BulkAccountLoader;
+}());
+exports.BulkAccountLoader = BulkAccountLoader;

package/src/accounts/bulkUserStatsSubscription.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.bulkPollingUserStatsSubscribe = void 0;
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+function bulkPollingUserStatsSubscribe(userStats, accountLoader) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(userStats.length === 0)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, accountLoader.load()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+                case 2: return [4 /*yield*/, Promise.all(userStats.map(function (userStat) {
+                        return userStat.accountSubscriber.addToAccountLoader();
+                    }))];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, accountLoader.load()];
+                case 4:
+                    _a.sent();
+                    return [4 /*yield*/, Promise.all(userStats.map(function (userStat) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, userStat.subscribe()];
+                            });
+                        }); }))];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.bulkPollingUserStatsSubscribe = bulkPollingUserStatsSubscribe;

package/src/accounts/bulkUserSubscription.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.bulkPollingUserSubscribe = void 0;
+/**
+ * @param users
+ * @param accountLoader
+ */
+function bulkPollingUserSubscribe(users, accountLoader) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(users.length === 0)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, accountLoader.load()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+                case 2: return [4 /*yield*/, Promise.all(users.map(function (user) {
+                        return user.accountSubscriber.addToAccountLoader();
+                    }))];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, accountLoader.load()];
+                case 4:
+                    _a.sent();
+                    return [4 /*yield*/, Promise.all(users.map(function (user) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, user.subscribe()];
+                            });
+                        }); }))];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;