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

package/src/accounts/pollingClearingHouseAccountSubscriber.ts

@@ -1,72 +1,76 @@
 import {
+	DataAndSlot,
 	AccountToPoll,
 	ClearingHouseAccountEvents,
 	ClearingHouseAccountSubscriber,
-	ClearingHouseAccountTypes,
 	NotSubscribedError,
+	OraclesToPoll,
 } from './types';
-import { Program } from '@project-serum/anchor';
+import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
-	DepositHistoryAccount,
-	ExtendedCurveHistoryAccount,
-	FundingPaymentHistoryAccount,
-	FundingRateHistoryAccount,
-	LiquidationHistoryAccount,
-	MarketsAccount,
-	OrderHistoryAccount,
-	OrderStateAccount,
+	BankAccount,
+	MarketAccount,
 	StateAccount,
-	TradeHistoryAccount,
+	UserAccount,
 } from '../types';
-import { getClearingHouseStateAccountPublicKey } from '../addresses';
+import {
+	getClearingHouseStateAccountPublicKey,
+	getBankPublicKey,
+	getMarketPublicKey,
+} from '../addresses/pda';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { capitalize } from './utils';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
 import { PublicKey } from '@solana/web3.js';
-import { CLEARING_HOUSE_STATE_ACCOUNTS } from '../constants/accounts';
+import { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
+import { QUOTE_ORACLE_PRICE_DATA } from '../oracles/quoteAssetOracleClient';
 
 export class PollingClearingHouseAccountSubscriber
 	implements ClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
+	marketIndexes: BN[];
+	bankIndexes: BN[];
+	oracleInfos: OracleInfo[];
+	oracleClientCache = new OracleClientCache();
+
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
 
 	accountLoader: BulkAccountLoader;
 	accountsToPoll = new Map<string, AccountToPoll>();
+	oraclesToPoll = new Map<string, OraclesToPoll>();
 	errorCallbackId?: string;
 
-	state?: StateAccount;
-	markets?: MarketsAccount;
-	orderState?: OrderStateAccount;
-	tradeHistory?: TradeHistoryAccount;
-	depositHistory?: DepositHistoryAccount;
-	fundingPaymentHistory?: FundingPaymentHistoryAccount;
-	fundingRateHistory?: FundingRateHistoryAccount;
-	liquidationHistory?: LiquidationHistoryAccount;
-	extendedCurveHistory: ExtendedCurveHistoryAccount;
-	orderHistory?: OrderHistoryAccount;
-
-	optionalExtraSubscriptions: ClearingHouseAccountTypes[] = [];
-
-	type: ClearingHouseConfigType = 'polling';
+	state?: DataAndSlot<StateAccount>;
+	market = new Map<number, DataAndSlot<MarketAccount>>();
+	bank = new Map<number, DataAndSlot<BankAccount>>();
+	oracles = new Map<string, DataAndSlot<OraclePriceData>>();
+	user?: DataAndSlot<UserAccount>;
 
 	private isSubscribing = false;
 	private subscriptionPromise: Promise<boolean>;
 	private subscriptionPromiseResolver: (val: boolean) => void;
 
-	public constructor(program: Program, accountLoader: BulkAccountLoader) {
+	public constructor(
+		program: Program,
+		accountLoader: BulkAccountLoader,
+		marketIndexes: BN[],
+		bankIndexes: BN[],
+		oracleInfos: OracleInfo[]
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.eventEmitter = new EventEmitter();
 		this.accountLoader = accountLoader;
+		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;
 		}
@@ -75,8 +79,6 @@ export class PollingClearingHouseAccountSubscriber
 			return await this.subscriptionPromise;
 		}
 
-		this.optionalExtraSubscriptions = optionalSubscriptions;
-
 		this.isSubscribing = true;
 
 		this.subscriptionPromise = new Promise((res) => {
@@ -84,6 +86,7 @@ export class PollingClearingHouseAccountSubscriber
 		});
 
 		await this.updateAccountsToPoll();
+		await this.updateOraclesToPoll();
 		await this.addToAccountLoader();
 
 		let subscriptionSucceeded = false;
@@ -118,137 +121,94 @@ export class PollingClearingHouseAccountSubscriber
 			eventType: 'stateAccountUpdate',
 		});
 
-		this.accountsToPoll.set(accounts.markets.toString(), {
-			key: 'markets',
-			publicKey: accounts.markets,
-			eventType: 'marketsAccountUpdate',
-		});
+		await this.updateMarketAccountsToPoll();
+		await this.updateBankAccountsToPoll();
+	}
 
-		this.accountsToPoll.set(accounts.orderState.toString(), {
-			key: 'orderState',
-			publicKey: accounts.orderState,
-			eventType: 'orderStateAccountUpdate',
+	async updateMarketAccountsToPoll(): Promise<boolean> {
+		for (const marketIndex of this.marketIndexes) {
+			await this.addMarketAccountToPoll(marketIndex);
+		}
+		return true;
+	}
+
+	async addMarketAccountToPoll(marketIndex: BN): Promise<boolean> {
+		const marketPublicKey = await getMarketPublicKey(
+			this.program.programId,
+			marketIndex
+		);
+
+		this.accountsToPoll.set(marketPublicKey.toString(), {
+			key: 'market',
+			publicKey: marketPublicKey,
+			eventType: 'marketAccountUpdate',
+			mapKey: marketIndex.toNumber(),
 		});
 
-		if (this.optionalExtraSubscriptions?.includes('tradeHistoryAccount')) {
-			this.accountsToPoll.set(accounts.tradeHistory.toString(), {
-				key: 'tradeHistory',
-				publicKey: accounts.tradeHistory,
-				eventType: 'tradeHistoryAccountUpdate',
-			});
-		}
+		return true;
+	}
 
-		if (this.optionalExtraSubscriptions?.includes('depositHistoryAccount')) {
-			this.accountsToPoll.set(accounts.depositHistory.toString(), {
-				key: 'depositHistory',
-				publicKey: accounts.depositHistory,
-				eventType: 'depositHistoryAccountUpdate',
-			});
+	async updateBankAccountsToPoll(): Promise<boolean> {
+		for (const bankIndex of this.bankIndexes) {
+			await this.addBankAccountToPoll(bankIndex);
 		}
 
-		if (
-			this.optionalExtraSubscriptions?.includes('fundingPaymentHistoryAccount')
-		) {
-			this.accountsToPoll.set(accounts.fundingPaymentHistory.toString(), {
-				key: 'fundingPaymentHistory',
-				publicKey: accounts.fundingPaymentHistory,
-				eventType: 'fundingPaymentHistoryAccountUpdate',
-			});
-		}
+		return true;
+	}
 
-		if (
-			this.optionalExtraSubscriptions?.includes('fundingRateHistoryAccount')
-		) {
-			this.accountsToPoll.set(accounts.fundingRateHistory.toString(), {
-				key: 'fundingRateHistory',
-				publicKey: accounts.fundingRateHistory,
-				eventType: 'fundingRateHistoryAccountUpdate',
-			});
-		}
+	async addBankAccountToPoll(bankIndex: BN): Promise<boolean> {
+		const bankPublicKey = await getBankPublicKey(
+			this.program.programId,
+			bankIndex
+		);
 
-		if (this.optionalExtraSubscriptions?.includes('curveHistoryAccount')) {
-			this.accountsToPoll.set(accounts.extendedCurveHistory.toString(), {
-				key: 'extendedCurveHistory',
-				publicKey: accounts.extendedCurveHistory,
-				eventType: 'curveHistoryAccountUpdate',
-			});
-		}
+		this.accountsToPoll.set(bankPublicKey.toString(), {
+			key: 'bank',
+			publicKey: bankPublicKey,
+			eventType: 'bankAccountUpdate',
+			mapKey: bankIndex.toNumber(),
+		});
+		return true;
+	}
 
-		if (
-			this.optionalExtraSubscriptions?.includes('liquidationHistoryAccount')
-		) {
-			this.accountsToPoll.set(accounts.liquidationHistory.toString(), {
-				key: 'liquidationHistory',
-				publicKey: accounts.liquidationHistory,
-				eventType: 'liquidationHistoryAccountUpdate',
-			});
+	updateOraclesToPoll(): boolean {
+		for (const oracleInfo of this.oracleInfos) {
+			if (!oracleInfo.publicKey.equals(PublicKey.default)) {
+				this.addOracleToPoll(oracleInfo);
+			}
 		}
 
-		if (this.optionalExtraSubscriptions?.includes('orderHistoryAccount')) {
-			this.accountsToPoll.set(accounts.orderHistory.toString(), {
-				key: 'orderHistory',
-				publicKey: accounts.orderHistory,
-				eventType: 'orderHistoryAccountUpdate',
-			});
-		}
+		return true;
 	}
 
-	async getClearingHouseAccounts(): Promise<ClearingHouseAccounts> {
-		// Skip extra calls to rpc if we already know all the accounts
-		if (CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()]) {
-			return CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()];
-		}
+	addOracleToPoll(oracleInfo: OracleInfo): boolean {
+		this.oraclesToPoll.set(oracleInfo.publicKey.toString(), {
+			publicKey: oracleInfo.publicKey,
+			source: oracleInfo.source,
+		});
 
+		return true;
+	}
+
+	async getClearingHouseAccounts(): Promise<ClearingHouseAccounts> {
 		const statePublicKey = await getClearingHouseStateAccountPublicKey(
 			this.program.programId
 		);
 
-		const state = (await this.program.account.state.fetch(
-			statePublicKey
-		)) as StateAccount;
-
 		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 (this.optionalExtraSubscriptions?.includes('orderHistoryAccount')) {
-			const orderState = (await this.program.account.orderState.fetch(
-				state.orderState
-			)) as OrderStateAccount;
-
-			accounts.orderHistory = orderState.orderHistory;
-		}
-
 		return accounts;
 	}
 
 	async addToAccountLoader(): Promise<void> {
 		for (const [_, accountToPoll] of this.accountsToPoll) {
-			accountToPoll.callbackId = this.accountLoader.addAccount(
-				accountToPoll.publicKey,
-				(buffer) => {
-					const account = this.program.account[
-						accountToPoll.key
-					].coder.accounts.decode(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.addAccountToAccountLoader(accountToPoll);
+		}
+
+		for (const [_, oracleToPoll] of this.oraclesToPoll) {
+			this.addOracleToAccountLoader(oracleToPoll);
 		}
 
 		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
@@ -256,27 +216,114 @@ export class PollingClearingHouseAccountSubscriber
 		});
 	}
 
+	addAccountToAccountLoader(accountToPoll: AccountToPoll): void {
+		accountToPoll.callbackId = this.accountLoader.addAccount(
+			accountToPoll.publicKey,
+			(buffer: Buffer, slot: number) => {
+				if (!buffer) return;
+
+				const account = this.program.account[
+					accountToPoll.key
+				].coder.accounts.decode(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: OraclesToPoll): void {
+		const oracleClient = this.oracleClientCache.get(
+			oracleToPoll.source,
+			this.program.provider.connection
+		);
+
+		oracleToPoll.callbackId = this.accountLoader.addAccount(
+			oracleToPoll.publicKey,
+			(buffer: Buffer, slot: number) => {
+				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');
+			}
+		);
+	}
+
 	public async fetch(): Promise<void> {
 		await this.accountLoader.load();
 		for (const [_, accountToPoll] of this.accountsToPoll) {
-			const buffer = this.accountLoader.getAccountData(accountToPoll.publicKey);
+			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+				accountToPoll.publicKey
+			);
 			if (buffer) {
-				this[accountToPoll.key] = this.program.account[
+				const account = this.program.account[
 					accountToPoll.key
 				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+
+				if (accountToPoll.mapKey != undefined) {
+					this[accountToPoll.key].set(accountToPoll.mapKey, {
+						data: account,
+						slot,
+					});
+				} else {
+					this[accountToPoll.key] = {
+						data: account,
+						slot,
+					};
+				}
 			}
 		}
-	}
 
-	didSubscriptionSucceed(): boolean {
-		let success = true;
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			if (!this[accountToPoll.key]) {
-				success = false;
-				break;
+		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,
+				});
 			}
 		}
-		return success;
+	}
+
+	didSubscriptionSucceed(): boolean {
+		if (this.state) return true;
+
+		return false;
 	}
 
 	public async unsubscribe(): Promise<void> {
@@ -291,104 +338,92 @@ export class PollingClearingHouseAccountSubscriber
 			);
 		}
 
+		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;
 	}
 
-	assertIsSubscribed(): void {
-		if (!this.isSubscribed) {
-			throw new NotSubscribedError(
-				'You must call `subscribe` before using this function'
-			);
+	async addBank(bankIndex: BN): Promise<boolean> {
+		await this.addBankAccountToPoll(bankIndex);
+		const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+		this.addAccountToAccountLoader(accountToPoll);
+		return true;
+	}
+
+	async addMarket(marketIndex: BN): Promise<boolean> {
+		await this.addMarketAccountToPoll(marketIndex);
+		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
+		this.addAccountToAccountLoader(accountToPoll);
+		return true;
+	}
+
+	async addOracle(oracleInfo: OracleInfo): Promise<boolean> {
+		if (oracleInfo.publicKey.equals(PublicKey.default)) {
+			return true;
 		}
+
+		this.addOracleToPoll(oracleInfo);
+		const oracleToPoll = this.oraclesToPoll.get(
+			oracleInfo.publicKey.toString()
+		);
+		this.addOracleToAccountLoader(oracleToPoll);
+		return true;
 	}
 
-	assertOptionalIsSubscribed(
-		optionalSubscription: ClearingHouseAccountTypes
-	): void {
+	assertIsSubscribed(): 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.state;
 	}
 
-	public getMarketsAccount(): MarketsAccount {
-		this.assertIsSubscribed();
-		return this.markets;
-	}
-
-	public getOrderStateAccount(): OrderStateAccount {
-		this.assertIsSubscribed();
-		return this.orderState;
-	}
-
-	public getTradeHistoryAccount(): TradeHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('tradeHistoryAccount');
-		return this.tradeHistory;
+	public getMarketAccountAndSlot(
+		marketIndex: BN
+	): DataAndSlot<MarketAccount> | undefined {
+		return this.market.get(marketIndex.toNumber());
 	}
 
-	public getDepositHistoryAccount(): DepositHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('depositHistoryAccount');
-		return this.depositHistory;
+	public getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[] {
+		return Array.from(this.market.values());
 	}
 
-	public getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('fundingPaymentHistoryAccount');
-		return this.fundingPaymentHistory;
-	}
-
-	public getFundingRateHistoryAccount(): FundingRateHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('fundingRateHistoryAccount');
-		return this.fundingRateHistory;
+	public getBankAccountAndSlot(
+		bankIndex: BN
+	): DataAndSlot<BankAccount> | undefined {
+		return this.bank.get(bankIndex.toNumber());
 	}
 
-	public getCurveHistoryAccount(): ExtendedCurveHistoryAccount {
+	public getOraclePriceDataAndSlot(
+		oraclePublicKey: PublicKey
+	): DataAndSlot<OraclePriceData> | undefined {
 		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('curveHistoryAccount');
-		return this.extendedCurveHistory;
-	}
-
-	public getLiquidationHistoryAccount(): LiquidationHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('liquidationHistoryAccount');
-		return this.liquidationHistory;
-	}
+		if (oraclePublicKey.equals(PublicKey.default)) {
+			return {
+				data: QUOTE_ORACLE_PRICE_DATA,
+				slot: 0,
+			};
+		}
 
-	public getOrderHistoryAccount(): OrderHistoryAccount {
-		this.assertIsSubscribed();
-		this.assertOptionalIsSubscribed('orderHistoryAccount');
-		return this.orderHistory;
+		return this.oracles.get(oraclePublicKey.toString());
 	}
 }
 
 type ClearingHouseAccounts = {
 	state: PublicKey;
-	markets: PublicKey;
-	orderState: PublicKey;
-	tradeHistory?: PublicKey;
-	depositHistory?: PublicKey;
-	fundingPaymentHistory?: PublicKey;
-	fundingRateHistory?: PublicKey;
-	extendedCurveHistory?: PublicKey;
-	liquidationHistory?: PublicKey;
-	orderHistory?: PublicKey;
 };