@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/lib/accounts/webSocketAccountSubscriber.js

@@ -1,39 +1,27 @@
 "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.WebSocketAccountSubscriber = void 0;
 const utils_1 = require("./utils");
 class WebSocketAccountSubscriber {
-    constructor(accountName, program, accountPublicKey) {
+    constructor(accountName, program, accountPublicKey, decodeBuffer) {
         this.accountName = accountName;
         this.program = program;
         this.accountPublicKey = accountPublicKey;
+        this.decodeBufferFn = decodeBuffer;
     }
-    subscribe(onChange) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.listenerId) {
-                return;
-            }
-            this.onChange = onChange;
-            yield this.fetch();
-            this.listenerId = this.program.provider.connection.onAccountChange(this.accountPublicKey, (accountInfo, context) => {
-                this.handleRpcResponse(context, accountInfo);
-            }, this.program.provider.opts.commitment);
-        });
+    async subscribe(onChange) {
+        if (this.listenerId) {
+            return;
+        }
+        this.onChange = onChange;
+        await this.fetch();
+        this.listenerId = this.program.provider.connection.onAccountChange(this.accountPublicKey, (accountInfo, context) => {
+            this.handleRpcResponse(context, accountInfo);
+        }, this.program.provider.opts.commitment);
     }
-    fetch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rpcResponse = yield this.program.provider.connection.getAccountInfoAndContext(this.accountPublicKey, this.program.provider.opts.commitment);
-            this.handleRpcResponse(rpcResponse.context, rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value);
-        });
+    async fetch() {
+        const rpcResponse = await this.program.provider.connection.getAccountInfoAndContext(this.accountPublicKey, this.program.provider.opts.commitment);
+        this.handleRpcResponse(rpcResponse.context, rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value);
     }
     handleRpcResponse(context, accountInfo) {
         const newSlot = context.slot;
@@ -41,28 +29,44 @@ class WebSocketAccountSubscriber {
         if (accountInfo) {
             newBuffer = accountInfo.data;
         }
-        if (!this.accountData) {
-            this.accountData = {
+        if (!this.bufferAndSlot) {
+            this.bufferAndSlot = {
                 buffer: newBuffer,
                 slot: newSlot,
             };
             if (newBuffer) {
-                this.data = this.program.account[this.accountName].coder.accounts.decode((0, utils_1.capitalize)(this.accountName), newBuffer);
-                this.onChange(this.data);
+                const account = this.decodeBuffer(newBuffer);
+                this.dataAndSlot = {
+                    data: account,
+                    slot: newSlot,
+                };
+                this.onChange(account);
             }
             return;
         }
-        if (newSlot <= this.accountData.slot) {
+        if (newSlot <= this.bufferAndSlot.slot) {
             return;
         }
-        const oldBuffer = this.accountData.buffer;
+        const oldBuffer = this.bufferAndSlot.buffer;
         if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-            this.accountData = {
+            this.bufferAndSlot = {
                 buffer: newBuffer,
                 slot: newSlot,
             };
-            this.data = this.program.account[this.accountName].coder.accounts.decode((0, utils_1.capitalize)(this.accountName), newBuffer);
-            this.onChange(this.data);
+            const account = this.decodeBuffer(newBuffer);
+            this.dataAndSlot = {
+                data: account,
+                slot: newSlot,
+            };
+            this.onChange(account);
+        }
+    }
+    decodeBuffer(buffer) {
+        if (this.decodeBufferFn) {
+            return this.decodeBufferFn(buffer);
+        }
+        else {
+            return this.program.account[this.accountName].coder.accounts.decode((0, utils_1.capitalize)(this.accountName), buffer);
         }
     }
     unsubscribe() {

package/lib/accounts/webSocketClearingHouseAccountSubscriber.d.ts

@@ -1,44 +1,49 @@
+/// <reference types="bn.js" />
 /// <reference types="node" />
-import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, ClearingHouseAccountTypes } from './types';
+import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './types';
 import { AccountSubscriber } from './types';
-import { DepositHistoryAccount, ExtendedCurveHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, LiquidationHistoryAccount, MarketsAccount, OrderHistoryAccount, OrderStateAccount, StateAccount, TradeHistoryAccount } from '../types';
-import { Program } from '@project-serum/anchor';
+import { BankAccount, MarketAccount, StateAccount } from '../types';
+import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
 export declare class WebSocketClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
+    marketIndexes: BN[];
+    bankIndexes: BN[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
     stateAccountSubscriber?: AccountSubscriber<StateAccount>;
-    marketsAccountSubscriber?: AccountSubscriber<MarketsAccount>;
-    tradeHistoryAccountSubscriber?: AccountSubscriber<TradeHistoryAccount>;
-    depositHistoryAccountSubscriber?: AccountSubscriber<DepositHistoryAccount>;
-    fundingPaymentHistoryAccountSubscriber?: AccountSubscriber<FundingPaymentHistoryAccount>;
-    fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
-    curveHistoryAccountSubscriber?: AccountSubscriber<ExtendedCurveHistoryAccount>;
-    liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
-    orderStateAccountSubscriber?: AccountSubscriber<OrderStateAccount>;
-    orderHistoryAccountSubscriber?: AccountSubscriber<OrderHistoryAccount>;
-    optionalExtraSubscriptions: ClearingHouseAccountTypes[];
-    type: ClearingHouseConfigType;
+    marketAccountSubscribers: Map<number, AccountSubscriber<MarketAccount>>;
+    bankAccountSubscribers: Map<number, AccountSubscriber<BankAccount>>;
+    oracleSubscribers: Map<string, AccountSubscriber<OraclePriceData>>;
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program);
-    subscribe(optionalSubscriptions?: ClearingHouseAccountTypes[]): Promise<boolean>;
+    constructor(program: Program, marketIndexes: BN[], bankIndexes: BN[], oracleInfos: OracleInfo[]);
+    subscribe(): Promise<boolean>;
+    subscribeToMarketAccounts(): Promise<boolean>;
+    subscribeToMarketAccount(marketIndex: BN): Promise<boolean>;
+    subscribeToBankAccounts(): Promise<boolean>;
+    subscribeToBankAccount(bankIndex: BN): Promise<boolean>;
+    subscribeToOracles(): Promise<boolean>;
+    subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    unsubscribeFromMarketAccounts(): Promise<void>;
+    unsubscribeFromBankAccounts(): Promise<void>;
+    unsubscribeFromOracles(): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
+    addBank(bankIndex: BN): Promise<boolean>;
+    addMarket(marketIndex: BN): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
-    assertOptionalIsSubscribed(optionalSubscription: ClearingHouseAccountTypes): void;
-    getStateAccount(): StateAccount;
-    getMarketsAccount(): MarketsAccount;
-    getTradeHistoryAccount(): TradeHistoryAccount;
-    getDepositHistoryAccount(): DepositHistoryAccount;
-    getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-    getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-    getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
-    getLiquidationHistoryAccount(): LiquidationHistoryAccount;
-    getOrderHistoryAccount(): OrderHistoryAccount;
-    getOrderStateAccount(): OrderStateAccount;
+    getStateAccountAndSlot(): DataAndSlot<StateAccount>;
+    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
+    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }

package/lib/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -1,226 +1,194 @@
 "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.WebSocketClearingHouseAccountSubscriber = void 0;
 const types_1 = require("./types");
 const events_1 = require("events");
-const addresses_1 = require("../addresses");
+const pda_1 = require("../addresses/pda");
 const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+const web3_js_1 = require("@solana/web3.js");
+const oracleClientCache_1 = require("../oracles/oracleClientCache");
+const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
 class WebSocketClearingHouseAccountSubscriber {
-    constructor(program) {
-        this.optionalExtraSubscriptions = [];
-        this.type = 'websocket';
+    constructor(program, marketIndexes, bankIndexes, oracleInfos) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.marketAccountSubscribers = new Map();
+        this.bankAccountSubscribers = new Map();
+        this.oracleSubscribers = new Map();
         this.isSubscribing = false;
         this.isSubscribed = false;
         this.program = program;
         this.eventEmitter = new events_1.EventEmitter();
+        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.isSubscribing = true;
-            this.subscriptionPromise = new Promise((res) => {
-                this.subscriptionPromiseResolver = res;
-            });
-            const statePublicKey = yield (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-            // create and activate main state account subscription
-            this.stateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('state', this.program, statePublicKey);
-            yield this.stateAccountSubscriber.subscribe((data) => {
-                this.eventEmitter.emit('stateAccountUpdate', data);
-                this.eventEmitter.emit('update');
-            });
-            const state = this.stateAccountSubscriber.data;
-            this.marketsAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('markets', this.program, state.markets);
-            yield this.marketsAccountSubscriber.subscribe((data) => {
-                this.eventEmitter.emit('marketsAccountUpdate', data);
-                this.eventEmitter.emit('update');
-            });
-            this.orderStateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('orderState', this.program, state.orderState);
-            yield this.orderStateAccountSubscriber.subscribe((data) => {
-                this.eventEmitter.emit('orderStateAccountUpdate', data);
-                this.eventEmitter.emit('update');
-            });
-            const orderState = this.orderStateAccountSubscriber.data;
-            // create subscribers for other state accounts
-            this.tradeHistoryAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('tradeHistory', this.program, state.tradeHistory);
-            this.depositHistoryAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('depositHistory', this.program, state.depositHistory);
-            this.fundingPaymentHistoryAccountSubscriber =
-                new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('fundingPaymentHistory', this.program, state.fundingPaymentHistory);
-            this.fundingRateHistoryAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('fundingRateHistory', this.program, state.fundingRateHistory);
-            this.liquidationHistoryAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('liquidationHistory', this.program, state.liquidationHistory);
-            this.curveHistoryAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('extendedCurveHistory', this.program, state.extendedCurveHistory);
-            this.orderHistoryAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('orderHistory', this.program, orderState.orderHistory);
-            const extraSusbcribersToUse = [];
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('tradeHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.tradeHistoryAccountSubscriber,
-                    eventType: 'tradeHistoryAccountUpdate',
-                });
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('depositHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.depositHistoryAccountSubscriber,
-                    eventType: 'depositHistoryAccountUpdate',
-                });
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('fundingPaymentHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.fundingPaymentHistoryAccountSubscriber,
-                    eventType: 'fundingPaymentHistoryAccountUpdate',
-                });
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('fundingRateHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.fundingRateHistoryAccountSubscriber,
-                    eventType: 'fundingRateHistoryAccountUpdate',
-                });
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('liquidationHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.liquidationHistoryAccountSubscriber,
-                    eventType: 'liquidationHistoryAccountUpdate',
-                });
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('curveHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.curveHistoryAccountSubscriber,
-                    eventType: 'curveHistoryAccountUpdate',
-                });
-            if (optionalSubscriptions === null || optionalSubscriptions === void 0 ? void 0 : optionalSubscriptions.includes('orderHistoryAccount'))
-                extraSusbcribersToUse.push({
-                    subscriber: this.orderHistoryAccountSubscriber,
-                    eventType: 'orderHistoryAccountUpdate',
-                });
-            this.optionalExtraSubscriptions = optionalSubscriptions !== null && optionalSubscriptions !== void 0 ? optionalSubscriptions : [];
-            // await all subcriptions in parallel to boost performance
-            //// the state account subscription above can't happen in here, because some of these susbcriptions are dependent on clearing house state being available
-            yield Promise.all(extraSusbcribersToUse.map(({ subscriber, eventType }) => subscriber.subscribe((data) => {
-                this.eventEmitter.emit(eventType, data);
-                this.eventEmitter.emit('update');
-            })));
-            this.eventEmitter.emit('update');
-            this.isSubscribing = false;
-            this.isSubscribed = true;
-            this.subscriptionPromiseResolver(true);
+    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;
+        });
+        const statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
+        // create and activate main state account subscription
+        this.stateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('state', this.program, statePublicKey);
+        await this.stateAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('stateAccountUpdate', data);
+            this.eventEmitter.emit('update');
         });
+        // subscribe to market accounts
+        await this.subscribeToMarketAccounts();
+        // subscribe to bank accounts
+        await this.subscribeToBankAccounts();
+        // subscribe to oracles
+        await this.subscribeToOracles();
+        this.eventEmitter.emit('update');
+        this.isSubscribing = false;
+        this.isSubscribed = true;
+        this.subscriptionPromiseResolver(true);
+        return true;
     }
-    fetch() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isSubscribed) {
-                return;
-            }
-            const promises = this.optionalExtraSubscriptions
-                .map((optionalSubscription) => {
-                const subscriber = `${optionalSubscription}Subscriber`;
-                return this[subscriber].fetch();
-            })
-                .concat([
-                this.stateAccountSubscriber.fetch(),
-                this.marketsAccountSubscriber.fetch(),
-            ]);
-            yield Promise.all(promises);
+    async subscribeToMarketAccounts() {
+        for (const marketIndex of this.marketIndexes) {
+            await this.subscribeToMarketAccount(marketIndex);
+        }
+        return true;
+    }
+    async subscribeToMarketAccount(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('market', this.program, marketPublicKey);
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('marketAccountUpdate', data);
+            this.eventEmitter.emit('update');
         });
+        this.marketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+        return true;
     }
-    unsubscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isSubscribed) {
-                return;
-            }
-            yield this.stateAccountSubscriber.unsubscribe();
-            yield this.marketsAccountSubscriber.unsubscribe();
-            yield this.orderStateAccountSubscriber.unsubscribe();
-            if (this.optionalExtraSubscriptions.includes('tradeHistoryAccount')) {
-                yield this.tradeHistoryAccountSubscriber.unsubscribe();
-            }
-            if (this.optionalExtraSubscriptions.includes('fundingRateHistoryAccount')) {
-                yield this.fundingRateHistoryAccountSubscriber.unsubscribe();
-            }
-            if (this.optionalExtraSubscriptions.includes('fundingPaymentHistoryAccount')) {
-                yield this.fundingPaymentHistoryAccountSubscriber.unsubscribe();
-            }
-            if (this.optionalExtraSubscriptions.includes('depositHistoryAccount')) {
-                yield this.depositHistoryAccountSubscriber.unsubscribe();
-            }
-            if (this.optionalExtraSubscriptions.includes('curveHistoryAccount')) {
-                yield this.curveHistoryAccountSubscriber.unsubscribe();
-            }
-            if (this.optionalExtraSubscriptions.includes('liquidationHistoryAccount')) {
-                yield this.liquidationHistoryAccountSubscriber.unsubscribe();
-            }
-            if (this.optionalExtraSubscriptions.includes('orderHistoryAccount')) {
-                yield this.orderHistoryAccountSubscriber.unsubscribe();
+    async subscribeToBankAccounts() {
+        for (const bankIndex of this.bankIndexes) {
+            await this.subscribeToBankAccount(bankIndex);
+        }
+        return true;
+    }
+    async subscribeToBankAccount(bankIndex) {
+        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('bank', this.program, bankPublicKey);
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('bankAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+        return true;
+    }
+    async subscribeToOracles() {
+        for (const oracleInfo of this.oracleInfos) {
+            if (!oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                await this.subscribeToOracle(oracleInfo);
             }
-            this.isSubscribed = false;
+        }
+        return true;
+    }
+    async subscribeToOracle(oracleInfo) {
+        const client = this.oracleClientCache.get(oracleInfo.source, this.program.provider.connection);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('oracle', this.program, oracleInfo.publicKey, (buffer) => {
+            return client.getOraclePriceDataFromBuffer(buffer);
         });
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+            this.eventEmitter.emit('update');
+        });
+        this.oracleSubscribers.set(oracleInfo.publicKey.toString(), accountSubscriber);
+        return true;
     }
-    assertIsSubscribed() {
-        if (!this.isSubscribed) {
-            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+    async unsubscribeFromMarketAccounts() {
+        for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+            await accountSubscriber.unsubscribe();
         }
     }
-    assertOptionalIsSubscribed(optionalSubscription) {
-        if (!this.isSubscribed) {
-            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+    async unsubscribeFromBankAccounts() {
+        for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+            await accountSubscriber.unsubscribe();
         }
-        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`);
+    }
+    async unsubscribeFromOracles() {
+        for (const accountSubscriber of this.oracleSubscribers.values()) {
+            await accountSubscriber.unsubscribe();
         }
     }
-    getStateAccount() {
-        this.assertIsSubscribed();
-        return this.stateAccountSubscriber.data;
+    async fetch() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        const promises = [this.stateAccountSubscriber.fetch()]
+            .concat(Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
+            .concat(Array.from(this.bankAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
+        await Promise.all(promises);
     }
-    getMarketsAccount() {
-        this.assertIsSubscribed();
-        return this.marketsAccountSubscriber.data;
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await this.stateAccountSubscriber.unsubscribe();
+        await this.unsubscribeFromMarketAccounts();
+        await this.unsubscribeFromBankAccounts();
+        await this.unsubscribeFromOracles();
+        this.isSubscribed = false;
     }
-    getTradeHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('tradeHistoryAccount');
-        return this.tradeHistoryAccountSubscriber.data;
+    async addBank(bankIndex) {
+        if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+            return true;
+        }
+        return this.subscribeToBankAccount(bankIndex);
     }
-    getDepositHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('depositHistoryAccount');
-        return this.depositHistoryAccountSubscriber.data;
+    async addMarket(marketIndex) {
+        if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+            return true;
+        }
+        return this.subscribeToMarketAccount(marketIndex);
     }
-    getFundingPaymentHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('fundingPaymentHistoryAccount');
-        return this.fundingPaymentHistoryAccountSubscriber.data;
+    async addOracle(oracleInfo) {
+        if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
+            return true;
+        }
+        if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+            return true;
+        }
+        return this.subscribeToOracle(oracleInfo);
     }
-    getFundingRateHistoryAccount() {
-        this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('fundingRateHistoryAccount');
-        return this.fundingRateHistoryAccountSubscriber.data;
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
     }
-    getCurveHistoryAccount() {
+    getStateAccountAndSlot() {
         this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('curveHistoryAccount');
-        return this.curveHistoryAccountSubscriber.data;
+        return this.stateAccountSubscriber.dataAndSlot;
     }
-    getLiquidationHistoryAccount() {
+    getMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('liquidationHistoryAccount');
-        return this.liquidationHistoryAccountSubscriber.data;
+        return this.marketAccountSubscribers.get(marketIndex.toNumber())
+            .dataAndSlot;
+    }
+    getMarketAccountsAndSlots() {
+        return Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
-    getOrderHistoryAccount() {
+    getBankAccountAndSlot(bankIndex) {
         this.assertIsSubscribed();
-        this.assertOptionalIsSubscribed('orderHistoryAccount');
-        return this.orderHistoryAccountSubscriber.data;
+        return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
     }
-    getOrderStateAccount() {
+    getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();
-        return this.orderStateAccountSubscriber.data;
+        if (oraclePublicKey.equals(web3_js_1.PublicKey.default)) {
+            return {
+                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
+                slot: 0,
+            };
+        }
+        return this.oracleSubscribers.get(oraclePublicKey.toString()).dataAndSlot;
     }
 }
 exports.WebSocketClearingHouseAccountSubscriber = WebSocketClearingHouseAccountSubscriber;

package/lib/accounts/webSocketUserAccountSubscriber.d.ts

@@ -1,26 +1,20 @@
 /// <reference types="node" />
-import { AccountSubscriber, UserAccountEvents, UserAccountSubscriber } from './types';
+import { DataAndSlot, AccountSubscriber, UserAccountEvents, UserAccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
-import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { UserAccount } from '../types';
 export declare class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
     eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
-    authority: PublicKey;
+    userAccountPublicKey: PublicKey;
     userDataAccountSubscriber: AccountSubscriber<UserAccount>;
-    userPositionsAccountSubscriber: AccountSubscriber<UserPositionsAccount>;
-    userOrdersAccountSubscriber: AccountSubscriber<UserOrdersAccount>;
-    type: ClearingHouseConfigType;
-    constructor(program: Program, authority: PublicKey);
+    constructor(program: Program, userAccountPublicKey: PublicKey);
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
     assertIsSubscribed(): void;
-    getUserAccount(): UserAccount;
-    getUserPositionsAccount(): UserPositionsAccount;
-    getUserOrdersAccount(): UserOrdersAccount;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
 }