@drift-labs/sdk 0.2.0-temp.0 → 0.2.0-temp.1

package/src/accounts/bulkAccountLoader.js

@@ -0,0 +1,197 @@
+"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.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;
+    }
+    addAccount(publicKey, callback) {
+        const existingSize = this.accountsToLoad.size;
+        const callbackId = 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();
+        }
+        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
+        this.loadPromise = undefined;
+        return callbackId;
+    }
+    removeAccount(publicKey, callbackId) {
+        const 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();
+        }
+    }
+    addErrorCallbacks(callback) {
+        const callbackId = 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));
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+                yield 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;
+            }
+        });
+    }
+    loadChunk(accountsToLoad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (accountsToLoad.length === 0) {
+                return;
+            }
+            const args = [
+                accountsToLoad.map((accountToLoad) => {
+                    return accountToLoad.publicKey.toBase58();
+                }),
+                { commitment: this.commitment },
+            ];
+            const rpcResponse = yield promiseTimeout_1.promiseTimeout(
+            // @ts-ignore
+            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
+            );
+            if (rpcResponse === null) {
+                this.log('request to rpc timed out');
+                return;
+            }
+            const newSlot = rpcResponse.result.context.slot;
+            if (newSlot > this.mostRecentSlot) {
+                this.mostRecentSlot = newSlot;
+            }
+            for (const i in accountsToLoad) {
+                const accountToLoad = accountsToLoad[i];
+                const key = accountToLoad.publicKey.toString();
+                const oldRPCResponse = this.bufferAndSlotMap.get(key);
+                let newBuffer = undefined;
+                if (rpcResponse.result.value[i]) {
+                    const raw = rpcResponse.result.value[i].data[0];
+                    const 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;
+                }
+                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) {
+            callback(buffer, slot);
+        }
+    }
+    getBufferAndSlot(publicKey) {
+        return this.bufferAndSlotMap.get(publicKey.toString());
+    }
+    startPolling() {
+        if (this.intervalId) {
+            return;
+        }
+        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/src/accounts/bulkUserSubscription.js

@@ -0,0 +1,33 @@
+"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.bulkPollingUserSubscribe = void 0;
+/**
+ * @param users
+ * @param accountLoader
+ */
+function bulkPollingUserSubscribe(users, accountLoader) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (users.length === 0) {
+            yield accountLoader.load();
+            return;
+        }
+        yield Promise.all(users.map((user) => {
+            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
+            return user.accountSubscriber.addToAccountLoader();
+        }));
+        yield accountLoader.load();
+        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
+            return user.subscribe();
+        })));
+    });
+}
+exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;

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;