@drift-labs/sdk 0.2.0-master.0 → 0.2.0-master.11

package/src/accounts/pollingClearingHouseAccountSubscriber.js

@@ -0,0 +1,311 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingClearingHouseAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const pda_1 = require("../addresses/pda");
+const utils_1 = require("./utils");
+const web3_js_1 = require("@solana/web3.js");
+const oracleClientCache_1 = require("../oracles/oracleClientCache");
+const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+class PollingClearingHouseAccountSubscriber {
+    constructor(program, accountLoader, marketIndexes, bankIndexes, oracleInfos) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.accountsToPoll = new Map();
+        this.oraclesToPoll = new Map();
+        this.market = new Map();
+        this.bank = new Map();
+        this.oracles = new Map();
+        this.isSubscribing = false;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.accountLoader = accountLoader;
+        this.marketIndexes = marketIndexes;
+        this.bankIndexes = bankIndexes;
+        this.oracleInfos = oracleInfos;
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            if (this.isSubscribing) {
+                return yield this.subscriptionPromise;
+            }
+            this.isSubscribing = true;
+            this.subscriptionPromise = new Promise((res) => {
+                this.subscriptionPromiseResolver = res;
+            });
+            yield this.updateAccountsToPoll();
+            yield this.updateOraclesToPoll();
+            yield this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetch();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribing = false;
+            this.isSubscribed = subscriptionSucceeded;
+            this.subscriptionPromiseResolver(subscriptionSucceeded);
+            return subscriptionSucceeded;
+        });
+    }
+    updateAccountsToPoll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.accountsToPoll.size > 0) {
+                return;
+            }
+            const accounts = yield this.getClearingHouseAccounts();
+            this.accountsToPoll.set(accounts.state.toString(), {
+                key: 'state',
+                publicKey: accounts.state,
+                eventType: 'stateAccountUpdate',
+            });
+            yield this.updateMarketAccountsToPoll();
+            yield this.updateBankAccountsToPoll();
+        });
+    }
+    updateMarketAccountsToPoll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const marketIndex of this.marketIndexes) {
+                yield this.addMarketAccountToPoll(marketIndex);
+            }
+            return true;
+        });
+    }
+    addMarketAccountToPoll(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            this.accountsToPoll.set(marketPublicKey.toString(), {
+                key: 'market',
+                publicKey: marketPublicKey,
+                eventType: 'marketAccountUpdate',
+                mapKey: marketIndex.toNumber(),
+            });
+            return true;
+        });
+    }
+    updateBankAccountsToPoll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const bankIndex of this.bankIndexes) {
+                yield this.addBankAccountToPoll(bankIndex);
+            }
+            return true;
+        });
+    }
+    addBankAccountToPoll(bankIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bankPublicKey = yield pda_1.getBankPublicKey(this.program.programId, bankIndex);
+            this.accountsToPoll.set(bankPublicKey.toString(), {
+                key: 'bank',
+                publicKey: bankPublicKey,
+                eventType: 'bankAccountUpdate',
+                mapKey: bankIndex.toNumber(),
+            });
+            return true;
+        });
+    }
+    updateOraclesToPoll() {
+        for (const oracleInfo of this.oracleInfos) {
+            if (!oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                this.addOracleToPoll(oracleInfo);
+            }
+        }
+        return true;
+    }
+    addOracleToPoll(oracleInfo) {
+        this.oraclesToPoll.set(oracleInfo.publicKey.toString(), {
+            publicKey: oracleInfo.publicKey,
+            source: oracleInfo.source,
+        });
+        return true;
+    }
+    getClearingHouseAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statePublicKey = yield pda_1.getClearingHouseStateAccountPublicKey(this.program.programId);
+            const accounts = {
+                state: statePublicKey,
+            };
+            return accounts;
+        });
+    }
+    addToAccountLoader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                this.addAccountToAccountLoader(accountToPoll);
+            }
+            for (const [_, oracleToPoll] of this.oraclesToPoll) {
+                this.addOracleToAccountLoader(oracleToPoll);
+            }
+            this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+                this.eventEmitter.emit('error', error);
+            });
+        });
+    }
+    addAccountToAccountLoader(accountToPoll) {
+        accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+            if (!buffer)
+                return;
+            const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+            const dataAndSlot = {
+                data: account,
+                slot,
+            };
+            if (accountToPoll.mapKey != undefined) {
+                this[accountToPoll.key].set(accountToPoll.mapKey, dataAndSlot);
+            }
+            else {
+                this[accountToPoll.key] = dataAndSlot;
+            }
+            // @ts-ignore
+            this.eventEmitter.emit(accountToPoll.eventType, account);
+            this.eventEmitter.emit('update');
+            if (!this.isSubscribed) {
+                this.isSubscribed = this.didSubscriptionSucceed();
+            }
+        });
+    }
+    addOracleToAccountLoader(oracleToPoll) {
+        const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection);
+        oracleToPoll.callbackId = this.accountLoader.addAccount(oracleToPoll.publicKey, (buffer, slot) => {
+            if (!buffer)
+                return;
+            const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);
+            const dataAndSlot = {
+                data: oraclePriceData,
+                slot,
+            };
+            this.oracles.set(oracleToPoll.publicKey.toString(), dataAndSlot);
+            this.eventEmitter.emit('oraclePriceUpdate', oracleToPoll.publicKey, oraclePriceData);
+            this.eventEmitter.emit('update');
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+                if (buffer) {
+                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                    if (accountToPoll.mapKey != undefined) {
+                        this[accountToPoll.key].set(accountToPoll.mapKey, {
+                            data: account,
+                            slot,
+                        });
+                    }
+                    else {
+                        this[accountToPoll.key] = {
+                            data: account,
+                            slot,
+                        };
+                    }
+                }
+            }
+            for (const [_, oracleToPoll] of this.oraclesToPoll) {
+                const { buffer, slot } = this.accountLoader.getBufferAndSlot(oracleToPoll.publicKey);
+                if (buffer) {
+                    const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection);
+                    const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);
+                    this.oracles.set(oracleToPoll.publicKey.toString(), {
+                        data: oraclePriceData,
+                        slot,
+                    });
+                }
+            }
+        });
+    }
+    didSubscriptionSucceed() {
+        if (this.state)
+            return true;
+        return false;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+            }
+            for (const [_, oracleToPoll] of this.oraclesToPoll) {
+                this.accountLoader.removeAccount(oracleToPoll.publicKey, oracleToPoll.callbackId);
+            }
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.accountsToPoll.clear();
+            this.oraclesToPoll.clear();
+            this.isSubscribed = false;
+        });
+    }
+    addBank(bankIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addBankAccountToPoll(bankIndex);
+            const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+            this.addAccountToAccountLoader(accountToPoll);
+            return true;
+        });
+    }
+    addMarket(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addMarketAccountToPoll(marketIndex);
+            const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+            this.addAccountToAccountLoader(accountToPoll);
+            return true;
+        });
+    }
+    addOracle(oracleInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                return true;
+            }
+            this.addOracleToPoll(oracleInfo);
+            const oracleToPoll = this.oraclesToPoll.get(oracleInfo.publicKey.toString());
+            this.addOracleToAccountLoader(oracleToPoll);
+            return true;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getStateAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.state;
+    }
+    getMarketAccountAndSlot(marketIndex) {
+        return this.market.get(marketIndex.toNumber());
+    }
+    getMarketAccountsAndSlots() {
+        return Array.from(this.market.values());
+    }
+    getBankAccountAndSlot(bankIndex) {
+        return this.bank.get(bankIndex.toNumber());
+    }
+    getOraclePriceDataAndSlot(oraclePublicKey) {
+        this.assertIsSubscribed();
+        if (oraclePublicKey.equals(web3_js_1.PublicKey.default)) {
+            return {
+                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
+                slot: 0,
+            };
+        }
+        return this.oracles.get(oraclePublicKey.toString());
+    }
+}
+exports.PollingClearingHouseAccountSubscriber = PollingClearingHouseAccountSubscriber;

package/src/accounts/pollingOracleSubscriber.js

@@ -0,0 +1,93 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingOracleSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingOracleSubscriber {
+    constructor(publicKey, oracleClient, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.oracleClient = oracleClient;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetch();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribed = subscriptionSucceeded;
+            return subscriptionSucceeded;
+        });
+    }
+    addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer, slot) => __awaiter(this, void 0, void 0, function* () {
+            const oraclePriceData = yield this.oracleClient.getOraclePriceDataFromBuffer(buffer);
+            this.oraclePriceData = { data: oraclePriceData, slot };
+            // @ts-ignore
+            this.eventEmitter.emit('oracleUpdate', oraclePriceData);
+            this.eventEmitter.emit('update');
+        }));
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+            this.oraclePriceData = {
+                data: yield this.oracleClient.getOraclePriceDataFromBuffer(buffer),
+                slot,
+            };
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            this.accountLoader.removeAccount(this.publicKey, this.callbackId);
+            this.callbackId = undefined;
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getOraclePriceData() {
+        this.assertIsSubscribed();
+        return this.oraclePriceData;
+    }
+    didSubscriptionSucceed() {
+        return !!this.oraclePriceData;
+    }
+}
+exports.PollingOracleSubscriber = PollingOracleSubscriber;

package/src/accounts/pollingTokenAccountSubscriber.js

@@ -0,0 +1,90 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingTokenAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const token_1 = require("../token");
+class PollingTokenAccountSubscriber {
+    constructor(publicKey, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetch();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribed = subscriptionSucceeded;
+            return subscriptionSucceeded;
+        });
+    }
+    addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer, slot) => {
+            const tokenAccount = token_1.parseTokenAccount(buffer);
+            this.tokenAccountAndSlot = { data: tokenAccount, slot };
+            // @ts-ignore
+            this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+            this.tokenAccountAndSlot = { data: token_1.parseTokenAccount(buffer), slot };
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            this.accountLoader.removeAccount(this.publicKey, this.callbackId);
+            this.callbackId = undefined;
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getTokenAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.tokenAccountAndSlot;
+    }
+    didSubscriptionSucceed() {
+        return !!this.tokenAccountAndSlot;
+    }
+}
+exports.PollingTokenAccountSubscriber = PollingTokenAccountSubscriber;

package/src/accounts/pollingUserAccountSubscriber.js

@@ -0,0 +1,132 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingUserAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const utils_1 = require("./utils");
+class PollingUserAccountSubscriber {
+    constructor(program, userAccountPublicKey, accountLoader) {
+        this.accountsToPoll = new Map();
+        this.isSubscribed = false;
+        this.program = program;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            yield this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetchIfUnloaded();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribed = subscriptionSucceeded;
+            return subscriptionSucceeded;
+        });
+    }
+    addToAccountLoader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.accountsToPoll.size > 0) {
+                return;
+            }
+            this.accountsToPoll.set(this.userAccountPublicKey.toString(), {
+                key: 'user',
+                publicKey: this.userAccountPublicKey,
+                eventType: 'userAccountUpdate',
+            });
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+                    if (!buffer) {
+                        return;
+                    }
+                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                    this[accountToPoll.key] = { data: account, slot };
+                    // @ts-ignore
+                    this.eventEmitter.emit(accountToPoll.eventType, account);
+                    this.eventEmitter.emit('update');
+                });
+            }
+            this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+                this.eventEmitter.emit('error', error);
+            });
+        });
+    }
+    fetchIfUnloaded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let shouldFetch = false;
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                if (this[accountToPoll.key] === undefined) {
+                    shouldFetch = true;
+                    break;
+                }
+            }
+            if (shouldFetch) {
+                yield this.fetch();
+            }
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+                if (buffer) {
+                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                    this[accountToPoll.key] = { data: account, slot };
+                }
+            }
+        });
+    }
+    didSubscriptionSucceed() {
+        let success = true;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (!this[accountToPoll.key]) {
+                success = false;
+                break;
+            }
+        }
+        return success;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+            }
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.accountsToPoll.clear();
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.user;
+    }
+}
+exports.PollingUserAccountSubscriber = PollingUserAccountSubscriber;

package/src/accounts/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotSubscribedError = void 0;
+class NotSubscribedError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'NotSubscribedError';
+    }
+}
+exports.NotSubscribedError = NotSubscribedError;

package/src/accounts/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = void 0;
+function capitalize(value) {
+    return value[0].toUpperCase() + value.slice(1);
+}
+exports.capitalize = capitalize;