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

package/src/accounts/webSocketClearingHouseAccountSubscriber.ts

@@ -1,62 +1,63 @@
 import {
 	ClearingHouseAccountSubscriber,
 	ClearingHouseAccountEvents,
-	ClearingHouseAccountTypes,
+	DataAndSlot,
 } from './types';
 import { AccountSubscriber, NotSubscribedError } 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 { getClearingHouseStateAccountPublicKey } from '../addresses';
+import {
+	getClearingHouseStateAccountPublicKey,
+	getBankPublicKey,
+	getMarketPublicKey,
+} from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
+import * as Buffer from 'buffer';
+import { QUOTE_ORACLE_PRICE_DATA } from '../oracles/quoteAssetOracleClient';
 
 export class WebSocketClearingHouseAccountSubscriber
 	implements ClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
+	marketIndexes: BN[];
+	bankIndexes: BN[];
+	oracleInfos: OracleInfo[];
+	oracleClientCache = new 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 = 'websocket';
+	marketAccountSubscribers = new Map<
+		number,
+		AccountSubscriber<MarketAccount>
+	>();
+	bankAccountSubscribers = new Map<number, AccountSubscriber<BankAccount>>();
+	oracleSubscribers = new Map<string, AccountSubscriber<OraclePriceData>>();
 
 	private isSubscribing = false;
 	private subscriptionPromise: Promise<boolean>;
 	private subscriptionPromiseResolver: (val: boolean) => void;
 
-	public constructor(program: Program) {
+	public constructor(
+		program: Program,
+		marketIndexes: BN[],
+		bankIndexes: BN[],
+		oracleInfos: OracleInfo[]
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.eventEmitter = new EventEmitter();
+		this.marketIndexes = marketIndexes;
+		this.bankIndexes = bankIndexes;
+		this.oracleInfos = oracleInfos;
 	}
 
-	public async subscribe(
-		optionalSubscriptions?: ClearingHouseAccountTypes[]
-	): Promise<boolean> {
+	public async subscribe(): Promise<boolean> {
 		if (this.isSubscribed) {
 			return true;
 		}
@@ -86,146 +87,129 @@ export class WebSocketClearingHouseAccountSubscriber
 			this.eventEmitter.emit('update');
 		});
 
-		const state = this.stateAccountSubscriber.data;
+		// subscribe to market accounts
+		await this.subscribeToMarketAccounts();
 
-		this.marketsAccountSubscriber = new WebSocketAccountSubscriber(
-			'markets',
-			this.program,
-			state.markets
-		);
+		// subscribe to bank accounts
+		await this.subscribeToBankAccounts();
 
-		await this.marketsAccountSubscriber.subscribe((data: MarketsAccount) => {
-			this.eventEmitter.emit('marketsAccountUpdate', data);
-			this.eventEmitter.emit('update');
-		});
+		// subscribe to oracles
+		await this.subscribeToOracles();
 
-		this.orderStateAccountSubscriber = new WebSocketAccountSubscriber(
-			'orderState',
-			this.program,
-			state.orderState
-		);
+		this.eventEmitter.emit('update');
 
-		await this.orderStateAccountSubscriber.subscribe(
-			(data: OrderStateAccount) => {
-				this.eventEmitter.emit('orderStateAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
+		this.isSubscribing = false;
+		this.isSubscribed = true;
+		this.subscriptionPromiseResolver(true);
 
-		const orderState = this.orderStateAccountSubscriber.data;
+		return true;
+	}
 
-		// create subscribers for other state accounts
+	async subscribeToMarketAccounts(): Promise<boolean> {
+		for (const marketIndex of this.marketIndexes) {
+			await this.subscribeToMarketAccount(marketIndex);
+		}
+		return true;
+	}
 
-		this.tradeHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'tradeHistory',
-			this.program,
-			state.tradeHistory
+	async subscribeToMarketAccount(marketIndex: BN): Promise<boolean> {
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
 		);
-
-		this.depositHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'depositHistory',
+		const accountSubscriber = new WebSocketAccountSubscriber<MarketAccount>(
+			'market',
 			this.program,
-			state.depositHistory
+			marketPublicKey
+		);
+		await accountSubscriber.subscribe((data: MarketAccount) => {
+			this.eventEmitter.emit('marketAccountUpdate', data);
+			this.eventEmitter.emit('update');
+		});
+		this.marketAccountSubscribers.set(
+			marketIndex.toNumber(),
+			accountSubscriber
 		);
+		return true;
+	}
 
-		this.fundingPaymentHistoryAccountSubscriber =
-			new WebSocketAccountSubscriber(
-				'fundingPaymentHistory',
-				this.program,
-				state.fundingPaymentHistory
-			);
+	async subscribeToBankAccounts(): Promise<boolean> {
+		for (const bankIndex of this.bankIndexes) {
+			await this.subscribeToBankAccount(bankIndex);
+		}
+		return true;
+	}
 
-		this.fundingRateHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'fundingRateHistory',
-			this.program,
-			state.fundingRateHistory
+	async subscribeToBankAccount(bankIndex: BN): Promise<boolean> {
+		const bankPublicKey = await getBankPublicKey(
+			this.program.programId,
+			bankIndex
 		);
-
-		this.liquidationHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'liquidationHistory',
+		const accountSubscriber = new WebSocketAccountSubscriber<BankAccount>(
+			'bank',
 			this.program,
-			state.liquidationHistory
+			bankPublicKey
 		);
+		await accountSubscriber.subscribe((data: BankAccount) => {
+			this.eventEmitter.emit('bankAccountUpdate', data);
+			this.eventEmitter.emit('update');
+		});
+		this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+		return true;
+	}
 
-		this.curveHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'extendedCurveHistory',
-			this.program,
-			state.extendedCurveHistory
-		);
+	async subscribeToOracles(): Promise<boolean> {
+		for (const oracleInfo of this.oracleInfos) {
+			if (!oracleInfo.publicKey.equals(PublicKey.default)) {
+				await this.subscribeToOracle(oracleInfo);
+			}
+		}
 
-		this.orderHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'orderHistory',
+		return true;
+	}
+
+	async subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean> {
+		const client = this.oracleClientCache.get(
+			oracleInfo.source,
+			this.program.provider.connection
+		);
+		const accountSubscriber = new WebSocketAccountSubscriber<OraclePriceData>(
+			'oracle',
 			this.program,
-			orderState.orderHistory
+			oracleInfo.publicKey,
+			(buffer: Buffer) => {
+				return client.getOraclePriceDataFromBuffer(buffer);
+			}
 		);
 
-		const extraSusbcribersToUse: {
-			subscriber: AccountSubscriber<any>;
-			eventType: keyof ClearingHouseAccountEvents;
-		}[] = [];
-
-		if (optionalSubscriptions?.includes('tradeHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.tradeHistoryAccountSubscriber,
-				eventType: 'tradeHistoryAccountUpdate',
-			});
-
-		if (optionalSubscriptions?.includes('depositHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.depositHistoryAccountSubscriber,
-				eventType: 'depositHistoryAccountUpdate',
-			});
-
-		if (optionalSubscriptions?.includes('fundingPaymentHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.fundingPaymentHistoryAccountSubscriber,
-				eventType: 'fundingPaymentHistoryAccountUpdate',
-			});
-
-		if (optionalSubscriptions?.includes('fundingRateHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.fundingRateHistoryAccountSubscriber,
-				eventType: 'fundingRateHistoryAccountUpdate',
-			});
-
-		if (optionalSubscriptions?.includes('liquidationHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.liquidationHistoryAccountSubscriber,
-				eventType: 'liquidationHistoryAccountUpdate',
-			});
-
-		if (optionalSubscriptions?.includes('curveHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.curveHistoryAccountSubscriber,
-				eventType: 'curveHistoryAccountUpdate',
-			});
-
-		if (optionalSubscriptions?.includes('orderHistoryAccount'))
-			extraSusbcribersToUse.push({
-				subscriber: this.orderHistoryAccountSubscriber,
-				eventType: 'orderHistoryAccountUpdate',
-			});
-
-		this.optionalExtraSubscriptions = 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
-		await Promise.all(
-			extraSusbcribersToUse.map(({ subscriber, eventType }) =>
-				subscriber.subscribe((data) => {
-					this.eventEmitter.emit(eventType, data);
-					this.eventEmitter.emit('update');
-				})
-			)
+		await accountSubscriber.subscribe((data: OraclePriceData) => {
+			this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+			this.eventEmitter.emit('update');
+		});
+
+		this.oracleSubscribers.set(
+			oracleInfo.publicKey.toString(),
+			accountSubscriber
 		);
+		return true;
+	}
 
-		this.eventEmitter.emit('update');
+	async unsubscribeFromMarketAccounts(): Promise<void> {
+		for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+			await accountSubscriber.unsubscribe();
+		}
+	}
 
-		this.isSubscribing = false;
-		this.isSubscribed = true;
-		this.subscriptionPromiseResolver(true);
+	async unsubscribeFromBankAccounts(): Promise<void> {
+		for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+			await accountSubscriber.unsubscribe();
+		}
+	}
 
-		return true;
+	async unsubscribeFromOracles(): Promise<void> {
+		for (const accountSubscriber of this.oracleSubscribers.values()) {
+			await accountSubscriber.unsubscribe();
+		}
 	}
 
 	public async fetch(): Promise<void> {
@@ -233,15 +217,17 @@ export class WebSocketClearingHouseAccountSubscriber
 			return;
 		}
 
-		const promises = this.optionalExtraSubscriptions
-			.map((optionalSubscription) => {
-				const subscriber = `${optionalSubscription}Subscriber`;
-				return this[subscriber].fetch();
-			})
-			.concat([
-				this.stateAccountSubscriber.fetch(),
-				this.marketsAccountSubscriber.fetch(),
-			]);
+		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);
 	}
@@ -252,40 +238,38 @@ export class WebSocketClearingHouseAccountSubscriber
 		}
 
 		await this.stateAccountSubscriber.unsubscribe();
-		await this.marketsAccountSubscriber.unsubscribe();
-		await this.orderStateAccountSubscriber.unsubscribe();
 
-		if (this.optionalExtraSubscriptions.includes('tradeHistoryAccount')) {
-			await this.tradeHistoryAccountSubscriber.unsubscribe();
-		}
+		await this.unsubscribeFromMarketAccounts();
+		await this.unsubscribeFromBankAccounts();
+		await this.unsubscribeFromOracles();
 
-		if (this.optionalExtraSubscriptions.includes('fundingRateHistoryAccount')) {
-			await this.fundingRateHistoryAccountSubscriber.unsubscribe();
-		}
-
-		if (
-			this.optionalExtraSubscriptions.includes('fundingPaymentHistoryAccount')
-		) {
-			await this.fundingPaymentHistoryAccountSubscriber.unsubscribe();
-		}
+		this.isSubscribed = false;
+	}
 
-		if (this.optionalExtraSubscriptions.includes('depositHistoryAccount')) {
-			await this.depositHistoryAccountSubscriber.unsubscribe();
+	async addBank(bankIndex: BN): Promise<boolean> {
+		if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+			return true;
 		}
+		return this.subscribeToBankAccount(bankIndex);
+	}
 
-		if (this.optionalExtraSubscriptions.includes('curveHistoryAccount')) {
-			await this.curveHistoryAccountSubscriber.unsubscribe();
+	async addMarket(marketIndex: BN): Promise<boolean> {
+		if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+			return true;
 		}
+		return this.subscribeToMarketAccount(marketIndex);
+	}
 
-		if (this.optionalExtraSubscriptions.includes('liquidationHistoryAccount')) {
-			await this.liquidationHistoryAccountSubscriber.unsubscribe();
+	async addOracle(oracleInfo: OracleInfo): Promise<boolean> {
+		if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
+			return true;
 		}
 
-		if (this.optionalExtraSubscriptions.includes('orderHistoryAccount')) {
-			await this.orderHistoryAccountSubscriber.unsubscribe();
+		if (oracleInfo.publicKey.equals(PublicKey.default)) {
+			return true;
 		}
 
-		this.isSubscribed = false;
+		return this.subscribeToOracle(oracleInfo);
 	}
 
 	assertIsSubscribed(): void {
@@ -296,76 +280,42 @@ export class WebSocketClearingHouseAccountSubscriber
 		}
 	}
 
-	assertOptionalIsSubscribed(
-		optionalSubscription: ClearingHouseAccountTypes
-	): void {
-		if (!this.isSubscribed) {
-			throw new NotSubscribedError(
-				'You must call `subscribe` before using this function'
-			);
-		}
-
-		if (!this.optionalExtraSubscriptions.includes(optionalSubscription)) {
-			throw new NotSubscribedError(
-				`You need to subscribe to the optional Clearing House account "${optionalSubscription}" to use this method`
-			);
-		}
-	}
-
-	public getStateAccount(): StateAccount {
+	public getStateAccountAndSlot(): DataAndSlot<StateAccount> {
 		this.assertIsSubscribed();
-		return this.stateAccountSubscriber.data;
+		return this.stateAccountSubscriber.dataAndSlot;
 	}
 
-	public getMarketsAccount(): MarketsAccount {
+	public getMarketAccountAndSlot(
+		marketIndex: BN
+	): DataAndSlot<MarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.marketsAccountSubscriber.data;
+		return this.marketAccountSubscribers.get(marketIndex.toNumber())
+			.dataAndSlot;
 	}
 
-	public getTradeHistoryAccount(): TradeHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('tradeHistoryAccount');
-		return this.tradeHistoryAccountSubscriber.data;
-	}
-
-	public getDepositHistoryAccount(): DepositHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('depositHistoryAccount');
-		return this.depositHistoryAccountSubscriber.data;
-	}
-
-	public getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('fundingPaymentHistoryAccount');
-		return this.fundingPaymentHistoryAccountSubscriber.data;
-	}
-
-	public getFundingRateHistoryAccount(): FundingRateHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('fundingRateHistoryAccount');
-		return this.fundingRateHistoryAccountSubscriber.data;
-	}
-
-	public getCurveHistoryAccount(): ExtendedCurveHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('curveHistoryAccount');
-		return this.curveHistoryAccountSubscriber.data;
-	}
-
-	public getLiquidationHistoryAccount(): LiquidationHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('liquidationHistoryAccount');
-		return this.liquidationHistoryAccountSubscriber.data;
+	public getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[] {
+		return Array.from(this.marketAccountSubscribers.values()).map(
+			(subscriber) => subscriber.dataAndSlot
+		);
 	}
 
-	public getOrderHistoryAccount(): OrderHistoryAccount {
+	public getBankAccountAndSlot(
+		bankIndex: BN
+	): DataAndSlot<BankAccount> | undefined {
 		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('orderHistoryAccount');
-		return this.orderHistoryAccountSubscriber.data;
+		return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
 	}
 
-	public getOrderStateAccount(): OrderStateAccount {
+	public getOraclePriceDataAndSlot(
+		oraclePublicKey: PublicKey
+	): DataAndSlot<OraclePriceData> | undefined {
 		this.assertIsSubscribed();
-		return this.orderStateAccountSubscriber.data;
+		if (oraclePublicKey.equals(PublicKey.default)) {
+			return {
+				data: QUOTE_ORACLE_PRICE_DATA,
+				slot: 0,
+			};
+		}
+		return this.oracleSubscribers.get(oraclePublicKey.toString()).dataAndSlot;
 	}
 }

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -1,4 +1,5 @@
 import {
+	DataAndSlot,
 	AccountSubscriber,
 	NotSubscribedError,
 	UserAccountEvents,
@@ -8,30 +9,21 @@ import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
-import {
-	getUserAccountPublicKey,
-	getUserOrdersAccountPublicKey,
-} from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { UserAccount } from '../types';
 
 export 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 = 'websocket';
 
-	public constructor(program: Program, authority: PublicKey) {
+	public constructor(program: Program, userAccountPublicKey: PublicKey) {
 		this.isSubscribed = false;
 		this.program = program;
-		this.authority = authority;
+		this.userAccountPublicKey = userAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
 	}
 
@@ -40,62 +32,23 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 			return true;
 		}
 
-		const userPublicKey = await getUserAccountPublicKey(
-			this.program.programId,
-			this.authority
-		);
 		this.userDataAccountSubscriber = new WebSocketAccountSubscriber(
 			'user',
 			this.program,
-			userPublicKey
+			this.userAccountPublicKey
 		);
 		await this.userDataAccountSubscriber.subscribe((data: UserAccount) => {
-			this.eventEmitter.emit('userAccountData', data);
+			this.eventEmitter.emit('userAccountUpdate', data);
 			this.eventEmitter.emit('update');
 		});
 
-		const userAccountData = this.userDataAccountSubscriber.data;
-		this.userPositionsAccountSubscriber = new WebSocketAccountSubscriber(
-			'userPositions',
-			this.program,
-			userAccountData.positions
-		);
-
-		await this.userPositionsAccountSubscriber.subscribe(
-			(data: UserPositionsAccount) => {
-				this.eventEmitter.emit('userPositionsData', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
-			this.program.programId,
-			userPublicKey
-		);
-
-		this.userOrdersAccountSubscriber = new WebSocketAccountSubscriber(
-			'userOrders',
-			this.program,
-			userOrdersPublicKey
-		);
-		await this.userOrdersAccountSubscriber.subscribe(
-			(data: UserOrdersAccount) => {
-				this.eventEmitter.emit('userOrdersData', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
 		this.eventEmitter.emit('update');
 		this.isSubscribed = true;
 		return true;
 	}
 
 	async fetch(): Promise<void> {
-		await Promise.all([
-			this.userDataAccountSubscriber.fetch(),
-			this.userPositionsAccountSubscriber.fetch(),
-			this.userOrdersAccountSubscriber.fetch(),
-		]);
+		await Promise.all([this.userDataAccountSubscriber.fetch()]);
 	}
 
 	async unsubscribe(): Promise<void> {
@@ -103,11 +56,7 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 			return;
 		}
 
-		await Promise.all([
-			this.userDataAccountSubscriber.unsubscribe(),
-			this.userPositionsAccountSubscriber.unsubscribe(),
-			await this.userOrdersAccountSubscriber.unsubscribe(),
-		]);
+		await Promise.all([this.userDataAccountSubscriber.unsubscribe()]);
 
 		this.isSubscribed = false;
 	}
@@ -120,17 +69,8 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 		}
 	}
 
-	public getUserAccount(): UserAccount {
+	public getUserAccountAndSlot(): DataAndSlot<UserAccount> {
 		this.assertIsSubscribed();
-		return this.userDataAccountSubscriber.data;
-	}
-
-	public getUserPositionsAccount(): UserPositionsAccount {
-		this.assertIsSubscribed();
-		return this.userPositionsAccountSubscriber.data;
-	}
-
-	public getUserOrdersAccount(): UserOrdersAccount {
-		return this.userOrdersAccountSubscriber.data;
+		return this.userDataAccountSubscriber.dataAndSlot;
 	}
 }

package/src/addresses/marketAddresses.ts

@@ -0,0 +1,18 @@
+import { PublicKey } from '@solana/web3.js';
+import { BN } from '@project-serum/anchor';
+import { getMarketPublicKey } from './pda';
+
+const CACHE = new Map<string, PublicKey>();
+export async function getMarketAddress(
+	programId: PublicKey,
+	marketIndex: BN
+): Promise<PublicKey> {
+	const cacheKey = `${programId.toString()}-${marketIndex.toString()}`;
+	if (CACHE.has(cacheKey)) {
+		return CACHE.get(cacheKey);
+	}
+
+	const publicKey = await getMarketPublicKey(programId, marketIndex);
+	CACHE.set(cacheKey, publicKey);
+	return publicKey;
+}