@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -1,276 +1,276 @@
 "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 addresses_1 = require("../addresses");
+const pda_1 = require("../addresses/pda");
 const utils_1 = require("./utils");
-const accounts_1 = require("../constants/accounts");
+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) {
+    constructor(program, accountLoader, marketIndexes, bankIndexes, oracleInfos) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
         this.accountsToPoll = new Map();
-        this.optionalExtraSubscriptions = [];
-        this.type = 'polling';
+        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(optionalSubscriptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isSubscribed) {
-                return true;
-            }
-            if (this.isSubscribing) {
-                return yield this.subscriptionPromise;
-            }
-            this.optionalExtraSubscriptions = optionalSubscriptions;
-            this.isSubscribing = true;
-            this.subscriptionPromise = new Promise((res) => {
-                this.subscriptionPromiseResolver = res;
-            });
-            yield this.updateAccountsToPoll();
-            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;
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (this.isSubscribing) {
+            return await this.subscriptionPromise;
+        }
+        this.isSubscribing = true;
+        this.subscriptionPromise = new Promise((res) => {
+            this.subscriptionPromiseResolver = res;
         });
+        await this.updateAccountsToPoll();
+        await this.updateOraclesToPoll();
+        await this.addToAccountLoader();
+        let subscriptionSucceeded = false;
+        let retries = 0;
+        while (!subscriptionSucceeded && retries < 5) {
+            await this.fetch();
+            subscriptionSucceeded = this.didSubscriptionSucceed();
+            retries++;
+        }
+        if (subscriptionSucceeded) {
+            this.eventEmitter.emit('update');
+        }
+        this.isSubscribing = false;
+        this.isSubscribed = subscriptionSucceeded;
+        this.subscriptionPromiseResolver(subscriptionSucceeded);
+        return subscriptionSucceeded;
     }
-    updateAccountsToPoll() {
-        var _a, _b, _c, _d, _e, _f, _g;
-        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',
-            });
-            this.accountsToPoll.set(accounts.markets.toString(), {
-                key: 'markets',
-                publicKey: accounts.markets,
-                eventType: 'marketsAccountUpdate',
-            });
-            this.accountsToPoll.set(accounts.orderState.toString(), {
-                key: 'orderState',
-                publicKey: accounts.orderState,
-                eventType: 'orderStateAccountUpdate',
-            });
-            if ((_a = this.optionalExtraSubscriptions) === null || _a === void 0 ? void 0 : _a.includes('tradeHistoryAccount')) {
-                this.accountsToPoll.set(accounts.tradeHistory.toString(), {
-                    key: 'tradeHistory',
-                    publicKey: accounts.tradeHistory,
-                    eventType: 'tradeHistoryAccountUpdate',
-                });
-            }
-            if ((_b = this.optionalExtraSubscriptions) === null || _b === void 0 ? void 0 : _b.includes('depositHistoryAccount')) {
-                this.accountsToPoll.set(accounts.depositHistory.toString(), {
-                    key: 'depositHistory',
-                    publicKey: accounts.depositHistory,
-                    eventType: 'depositHistoryAccountUpdate',
-                });
-            }
-            if ((_c = this.optionalExtraSubscriptions) === null || _c === void 0 ? void 0 : _c.includes('fundingPaymentHistoryAccount')) {
-                this.accountsToPoll.set(accounts.fundingPaymentHistory.toString(), {
-                    key: 'fundingPaymentHistory',
-                    publicKey: accounts.fundingPaymentHistory,
-                    eventType: 'fundingPaymentHistoryAccountUpdate',
-                });
-            }
-            if ((_d = this.optionalExtraSubscriptions) === null || _d === void 0 ? void 0 : _d.includes('fundingRateHistoryAccount')) {
-                this.accountsToPoll.set(accounts.fundingRateHistory.toString(), {
-                    key: 'fundingRateHistory',
-                    publicKey: accounts.fundingRateHistory,
-                    eventType: 'fundingRateHistoryAccountUpdate',
-                });
-            }
-            if ((_e = this.optionalExtraSubscriptions) === null || _e === void 0 ? void 0 : _e.includes('curveHistoryAccount')) {
-                this.accountsToPoll.set(accounts.extendedCurveHistory.toString(), {
-                    key: 'extendedCurveHistory',
-                    publicKey: accounts.extendedCurveHistory,
-                    eventType: 'curveHistoryAccountUpdate',
-                });
-            }
-            if ((_f = this.optionalExtraSubscriptions) === null || _f === void 0 ? void 0 : _f.includes('liquidationHistoryAccount')) {
-                this.accountsToPoll.set(accounts.liquidationHistory.toString(), {
-                    key: 'liquidationHistory',
-                    publicKey: accounts.liquidationHistory,
-                    eventType: 'liquidationHistoryAccountUpdate',
-                });
-            }
-            if ((_g = this.optionalExtraSubscriptions) === null || _g === void 0 ? void 0 : _g.includes('orderHistoryAccount')) {
-                this.accountsToPoll.set(accounts.orderHistory.toString(), {
-                    key: 'orderHistory',
-                    publicKey: accounts.orderHistory,
-                    eventType: 'orderHistoryAccountUpdate',
-                });
-            }
+    async updateAccountsToPoll() {
+        if (this.accountsToPoll.size > 0) {
+            return;
+        }
+        const accounts = await this.getClearingHouseAccounts();
+        this.accountsToPoll.set(accounts.state.toString(), {
+            key: 'state',
+            publicKey: accounts.state,
+            eventType: 'stateAccountUpdate',
         });
+        await this.updateMarketAccountsToPoll();
+        await this.updateBankAccountsToPoll();
     }
-    getClearingHouseAccounts() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // Skip extra calls to rpc if we already know all the accounts
-            if (accounts_1.CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()]) {
-                return accounts_1.CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()];
-            }
-            const statePublicKey = yield (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-            const state = (yield this.program.account.state.fetch(statePublicKey));
-            const accounts = {
-                state: statePublicKey,
-                markets: state.markets,
-                orderState: state.orderState,
-                tradeHistory: state.tradeHistory,
-                depositHistory: state.depositHistory,
-                fundingPaymentHistory: state.fundingPaymentHistory,
-                fundingRateHistory: state.fundingRateHistory,
-                extendedCurveHistory: state.extendedCurveHistory,
-                liquidationHistory: state.liquidationHistory,
-                orderHistory: undefined,
-            };
-            if ((_a = this.optionalExtraSubscriptions) === null || _a === void 0 ? void 0 : _a.includes('orderHistoryAccount')) {
-                const orderState = (yield this.program.account.orderState.fetch(state.orderState));
-                accounts.orderHistory = orderState.orderHistory;
-            }
-            return accounts;
+    async updateMarketAccountsToPoll() {
+        for (const marketIndex of this.marketIndexes) {
+            await this.addMarketAccountToPoll(marketIndex);
+        }
+        return true;
+    }
+    async addMarketAccountToPoll(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+        this.accountsToPoll.set(marketPublicKey.toString(), {
+            key: 'market',
+            publicKey: marketPublicKey,
+            eventType: 'marketAccountUpdate',
+            mapKey: marketIndex.toNumber(),
         });
+        return true;
     }
-    addToAccountLoader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer) => {
-                    const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, utils_1.capitalize)(accountToPoll.key), buffer);
-                    this[accountToPoll.key] = account;
-                    // @ts-ignore
-                    this.eventEmitter.emit(accountToPoll.eventType, account);
-                    this.eventEmitter.emit('update');
-                    if (!this.isSubscribed) {
-                        this.isSubscribed = this.didSubscriptionSucceed();
-                    }
-                });
-            }
-            this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
-                this.eventEmitter.emit('error', error);
-            });
+    async updateBankAccountsToPoll() {
+        for (const bankIndex of this.bankIndexes) {
+            await this.addBankAccountToPoll(bankIndex);
+        }
+        return true;
+    }
+    async addBankAccountToPoll(bankIndex) {
+        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
+        this.accountsToPoll.set(bankPublicKey.toString(), {
+            key: 'bank',
+            publicKey: bankPublicKey,
+            eventType: 'bankAccountUpdate',
+            mapKey: bankIndex.toNumber(),
         });
+        return true;
     }
-    fetch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.accountLoader.load();
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                const buffer = this.accountLoader.getAccountData(accountToPoll.publicKey);
-                if (buffer) {
-                    this[accountToPoll.key] = this.program.account[accountToPoll.key].coder.accounts.decode((0, utils_1.capitalize)(accountToPoll.key), buffer);
-                }
+    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;
     }
-    didSubscriptionSucceed() {
-        let success = true;
+    async getClearingHouseAccounts() {
+        const statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
+        const accounts = {
+            state: statePublicKey,
+        };
+        return accounts;
+    }
+    async addToAccountLoader() {
         for (const [_, accountToPoll] of this.accountsToPoll) {
-            if (!this[accountToPoll.key]) {
-                success = false;
-                break;
-            }
+            this.addAccountToAccountLoader(accountToPoll);
         }
-        return success;
+        for (const [_, oracleToPoll] of this.oraclesToPoll) {
+            this.addOracleToAccountLoader(oracleToPoll);
+        }
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
     }
-    unsubscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isSubscribed) {
+    addAccountToAccountLoader(accountToPoll) {
+        accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+            if (!buffer)
                 return;
+            const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, 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;
             }
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+            // @ts-ignore
+            this.eventEmitter.emit(accountToPoll.eventType, account);
+            this.eventEmitter.emit('update');
+            if (!this.isSubscribed) {
+                this.isSubscribed = this.didSubscriptionSucceed();
             }
-            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');
+    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');
+        });
+    }
+    async fetch() {
+        await 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((0, 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,
+                });
+            }
         }
     }
-    assertOptionalIsSubscribed(optionalSubscription) {
+    didSubscriptionSucceed() {
+        if (this.state)
+            return true;
+        return false;
+    }
+    async unsubscribe() {
         if (!this.isSubscribed) {
-            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+            return;
         }
-        if (!this.optionalExtraSubscriptions.includes(optionalSubscription)) {
-            throw new types_1.NotSubscribedError(`You need to subscribe to the optional Clearing House account "${optionalSubscription}" to use this method`);
+        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;
     }
-    getStateAccount() {
-        this.assertIsSubscribed();
-        return this.state;
+    async addBank(bankIndex) {
+        await this.addBankAccountToPoll(bankIndex);
+        const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+        this.addAccountToAccountLoader(accountToPoll);
+        return true;
     }
-    getMarketsAccount() {
-        this.assertIsSubscribed();
-        return this.markets;
+    async addMarket(marketIndex) {
+        await this.addMarketAccountToPoll(marketIndex);
+        const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+        this.addAccountToAccountLoader(accountToPoll);
+        return true;
     }
-    getOrderStateAccount() {
-        this.assertIsSubscribed();
-        return this.orderState;
-    }
-    getTradeHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('tradeHistoryAccount');
-        return this.tradeHistory;
+    async addOracle(oracleInfo) {
+        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;
     }
-    getDepositHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('depositHistoryAccount');
-        return this.depositHistory;
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
     }
-    getFundingPaymentHistoryAccount() {
+    getStateAccountAndSlot() {
         this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('fundingPaymentHistoryAccount');
-        return this.fundingPaymentHistory;
+        return this.state;
     }
-    getFundingRateHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('fundingRateHistoryAccount');
-        return this.fundingRateHistory;
+    getMarketAccountAndSlot(marketIndex) {
+        return this.market.get(marketIndex.toNumber());
     }
-    getCurveHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('curveHistoryAccount');
-        return this.extendedCurveHistory;
+    getMarketAccountsAndSlots() {
+        return Array.from(this.market.values());
     }
-    getLiquidationHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('liquidationHistoryAccount');
-        return this.liquidationHistory;
+    getBankAccountAndSlot(bankIndex) {
+        return this.bank.get(bankIndex.toNumber());
     }
-    getOrderHistoryAccount() {
+    getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('orderHistoryAccount');
-        return this.orderHistory;
+        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/lib/accounts/pollingOracleSubscriber.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { OracleEvents, OracleSubscriber } from './types';
+import { DataAndSlot, OracleEvents, OracleSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -15,13 +15,13 @@ export declare class PollingOracleSubscriber implements OracleSubscriber {
     oracleClient: OracleClient;
     callbackId?: string;
     errorCallbackId?: string;
-    oraclePriceData?: OraclePriceData;
+    oraclePriceData?: DataAndSlot<OraclePriceData>;
     constructor(publicKey: PublicKey, oracleClient: OracleClient, accountLoader: BulkAccountLoader);
     subscribe(): Promise<boolean>;
     addToAccountLoader(): void;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
     assertIsSubscribed(): void;
-    getOraclePriceData(): OraclePriceData;
+    getOraclePriceData(): DataAndSlot<OraclePriceData>;
     didSubscriptionSucceed(): boolean;
 }

package/lib/accounts/pollingOracleSubscriber.js

@@ -1,13 +1,4 @@
 "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");
@@ -20,59 +11,56 @@ class PollingOracleSubscriber {
         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;
-        });
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.addToAccountLoader();
+        let subscriptionSucceeded = false;
+        let retries = 0;
+        while (!subscriptionSucceeded && retries < 5) {
+            await 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) => __awaiter(this, void 0, void 0, function* () {
-            const oraclePriceData = yield this.oracleClient.getOraclePriceDataFromBuffer(buffer);
-            this.oraclePriceData = oraclePriceData;
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, async (buffer, slot) => {
+            const oraclePriceData = await 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 = this.accountLoader.getAccountData(this.publicKey);
-            this.oraclePriceData = yield this.oracleClient.getOraclePriceDataFromBuffer(buffer);
-        });
+    async fetch() {
+        await this.accountLoader.load();
+        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+        this.oraclePriceData = {
+            data: await 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;
-        });
+    async unsubscribe() {
+        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) {

package/lib/accounts/pollingTokenAccountSubscriber.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TokenAccountEvents, TokenAccountSubscriber } from './types';
+import { DataAndSlot, TokenAccountEvents, TokenAccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -14,13 +14,13 @@ export declare class PollingTokenAccountSubscriber implements TokenAccountSubscr
     accountLoader: BulkAccountLoader;
     callbackId?: string;
     errorCallbackId?: string;
-    tokenAccount?: AccountInfo;
+    tokenAccountAndSlot?: DataAndSlot<AccountInfo>;
     constructor(publicKey: PublicKey, accountLoader: BulkAccountLoader);
     subscribe(): Promise<boolean>;
     addToAccountLoader(): void;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
     assertIsSubscribed(): void;
-    getTokenAccount(): AccountInfo;
+    getTokenAccountAndSlot(): DataAndSlot<AccountInfo>;
     didSubscriptionSucceed(): boolean;
 }