@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/src/accounts/{pollingClearingHouseAccountSubscriber.ts → pollingDriftClientAccountSubscriber.ts}

@@ -1,24 +1,24 @@
 import {
 	DataAndSlot,
 	AccountToPoll,
-	ClearingHouseAccountEvents,
-	ClearingHouseAccountSubscriber,
+	DriftClientAccountEvents,
+	DriftClientAccountSubscriber,
 	NotSubscribedError,
 	OraclesToPoll,
 } from './types';
-import { BN, Program } from '@project-serum/anchor';
+import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
-	BankAccount,
-	MarketAccount,
+	SpotMarketAccount,
+	PerpMarketAccount,
 	StateAccount,
 	UserAccount,
 } from '../types';
 import {
-	getClearingHouseStateAccountPublicKey,
-	getBankPublicKey,
-	getMarketPublicKey,
+	getDriftStateAccountPublicKey,
+	getSpotMarketPublicKey,
+	getPerpMarketPublicKey,
 } from '../addresses/pda';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { capitalize } from './utils';
@@ -27,17 +27,17 @@ import { OracleInfo, OraclePriceData } from '../oracles/types';
 import { OracleClientCache } from '../oracles/oracleClientCache';
 import { QUOTE_ORACLE_PRICE_DATA } from '../oracles/quoteAssetOracleClient';
 
-export class PollingClearingHouseAccountSubscriber
-	implements ClearingHouseAccountSubscriber
+export class PollingDriftClientAccountSubscriber
+	implements DriftClientAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
-	marketIndexes: BN[];
-	bankIndexes: BN[];
+	perpMarketIndexes: number[];
+	spotMarketIndexes: number[];
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
-	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
 
 	accountLoader: BulkAccountLoader;
 	accountsToPoll = new Map<string, AccountToPoll>();
@@ -45,8 +45,8 @@ export class PollingClearingHouseAccountSubscriber
 	errorCallbackId?: string;
 
 	state?: DataAndSlot<StateAccount>;
-	market = new Map<number, DataAndSlot<MarketAccount>>();
-	bank = new Map<number, DataAndSlot<BankAccount>>();
+	perpMarket = new Map<number, DataAndSlot<PerpMarketAccount>>();
+	spotMarket = new Map<number, DataAndSlot<SpotMarketAccount>>();
 	oracles = new Map<string, DataAndSlot<OraclePriceData>>();
 	user?: DataAndSlot<UserAccount>;
 
@@ -57,16 +57,16 @@ export class PollingClearingHouseAccountSubscriber
 	public constructor(
 		program: Program,
 		accountLoader: BulkAccountLoader,
-		marketIndexes: BN[],
-		bankIndexes: BN[],
+		perpMarketIndexes: number[],
+		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[]
 	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.eventEmitter = new EventEmitter();
 		this.accountLoader = accountLoader;
-		this.marketIndexes = marketIndexes;
-		this.bankIndexes = bankIndexes;
+		this.perpMarketIndexes = perpMarketIndexes;
+		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 	}
 
@@ -113,60 +113,62 @@ export class PollingClearingHouseAccountSubscriber
 			return;
 		}
 
-		const accounts = await this.getClearingHouseAccounts();
+		const statePublicKey = await getDriftStateAccountPublicKey(
+			this.program.programId
+		);
 
-		this.accountsToPoll.set(accounts.state.toString(), {
+		this.accountsToPoll.set(statePublicKey.toString(), {
 			key: 'state',
-			publicKey: accounts.state,
+			publicKey: statePublicKey,
 			eventType: 'stateAccountUpdate',
 		});
 
-		await this.updateMarketAccountsToPoll();
-		await this.updateBankAccountsToPoll();
+		await this.updatePerpMarketAccountsToPoll();
+		await this.updateSpotMarketAccountsToPoll();
 	}
 
-	async updateMarketAccountsToPoll(): Promise<boolean> {
-		for (const marketIndex of this.marketIndexes) {
-			await this.addMarketAccountToPoll(marketIndex);
+	async updatePerpMarketAccountsToPoll(): Promise<boolean> {
+		for (const marketIndex of this.perpMarketIndexes) {
+			await this.addPerpMarketAccountToPoll(marketIndex);
 		}
 		return true;
 	}
 
-	async addMarketAccountToPoll(marketIndex: BN): Promise<boolean> {
-		const marketPublicKey = await getMarketPublicKey(
+	async addPerpMarketAccountToPoll(marketIndex: number): Promise<boolean> {
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
 			marketIndex
 		);
 
-		this.accountsToPoll.set(marketPublicKey.toString(), {
-			key: 'market',
-			publicKey: marketPublicKey,
-			eventType: 'marketAccountUpdate',
-			mapKey: marketIndex.toNumber(),
+		this.accountsToPoll.set(perpMarketPublicKey.toString(), {
+			key: 'perpMarket',
+			publicKey: perpMarketPublicKey,
+			eventType: 'perpMarketAccountUpdate',
+			mapKey: marketIndex,
 		});
 
 		return true;
 	}
 
-	async updateBankAccountsToPoll(): Promise<boolean> {
-		for (const bankIndex of this.bankIndexes) {
-			await this.addBankAccountToPoll(bankIndex);
+	async updateSpotMarketAccountsToPoll(): Promise<boolean> {
+		for (const marketIndex of this.spotMarketIndexes) {
+			await this.addSpotMarketAccountToPoll(marketIndex);
 		}
 
 		return true;
 	}
 
-	async addBankAccountToPoll(bankIndex: BN): Promise<boolean> {
-		const bankPublicKey = await getBankPublicKey(
+	async addSpotMarketAccountToPoll(marketIndex: number): Promise<boolean> {
+		const marketPublicKey = await getSpotMarketPublicKey(
 			this.program.programId,
-			bankIndex
+			marketIndex
 		);
 
-		this.accountsToPoll.set(bankPublicKey.toString(), {
-			key: 'bank',
-			publicKey: bankPublicKey,
-			eventType: 'bankAccountUpdate',
-			mapKey: bankIndex.toNumber(),
+		this.accountsToPoll.set(marketPublicKey.toString(), {
+			key: 'spotMarket',
+			publicKey: marketPublicKey,
+			eventType: 'spotMarketAccountUpdate',
+			mapKey: marketIndex,
 		});
 		return true;
 	}
@@ -190,18 +192,6 @@ export class PollingClearingHouseAccountSubscriber
 		return true;
 	}
 
-	async getClearingHouseAccounts(): Promise<ClearingHouseAccounts> {
-		const statePublicKey = await getClearingHouseStateAccountPublicKey(
-			this.program.programId
-		);
-
-		const accounts = {
-			state: statePublicKey,
-		};
-
-		return accounts;
-	}
-
 	async addToAccountLoader(): Promise<void> {
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			this.addAccountToAccountLoader(accountToPoll);
@@ -353,15 +343,15 @@ export class PollingClearingHouseAccountSubscriber
 		this.isSubscribed = false;
 	}
 
-	async addBank(bankIndex: BN): Promise<boolean> {
-		await this.addBankAccountToPoll(bankIndex);
-		const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+	async addSpotMarket(marketIndex: number): Promise<boolean> {
+		await this.addSpotMarketAccountToPoll(marketIndex);
+		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
 		this.addAccountToAccountLoader(accountToPoll);
 		return true;
 	}
 
-	async addMarket(marketIndex: BN): Promise<boolean> {
-		await this.addMarketAccountToPoll(marketIndex);
+	async addPerpMarket(marketIndex: number): Promise<boolean> {
+		await this.addPerpMarketAccountToPoll(marketIndex);
 		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
 		this.addAccountToAccountLoader(accountToPoll);
 		return true;
@@ -394,19 +384,23 @@ export class PollingClearingHouseAccountSubscriber
 	}
 
 	public getMarketAccountAndSlot(
-		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined {
-		return this.market.get(marketIndex.toNumber());
+		marketIndex: number
+	): DataAndSlot<PerpMarketAccount> | undefined {
+		return this.perpMarket.get(marketIndex);
+	}
+
+	public getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[] {
+		return Array.from(this.perpMarket.values());
 	}
 
-	public getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[] {
-		return Array.from(this.market.values());
+	public getSpotMarketAccountAndSlot(
+		marketIndex: number
+	): DataAndSlot<SpotMarketAccount> | undefined {
+		return this.spotMarket.get(marketIndex);
 	}
 
-	public getBankAccountAndSlot(
-		bankIndex: BN
-	): DataAndSlot<BankAccount> | undefined {
-		return this.bank.get(bankIndex.toNumber());
+	public getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[] {
+		return Array.from(this.spotMarket.values());
 	}
 
 	public getOraclePriceDataAndSlot(
@@ -423,7 +417,3 @@ export class PollingClearingHouseAccountSubscriber
 		return this.oracles.get(oraclePublicKey.toString());
 	}
 }
-
-type ClearingHouseAccounts = {
-	state: PublicKey;
-};

package/src/accounts/{pollingOracleSubscriber.ts → pollingOracleAccountSubscriber.ts}

@@ -2,7 +2,7 @@ import {
 	DataAndSlot,
 	NotSubscribedError,
 	OracleEvents,
-	OracleSubscriber,
+	OracleAccountSubscriber,
 } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
@@ -11,7 +11,7 @@ import { PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { OracleClient, OraclePriceData } from '../oracles/types';
 
-export class PollingOracleSubscriber implements OracleSubscriber {
+export class PollingOracleAccountSubscriber implements OracleAccountSubscriber {
 	isSubscribed: boolean;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -44,20 +44,13 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 
 		await this.addToAccountLoader();
 
-		let subscriptionSucceeded = false;
-		let retries = 0;
-		while (!subscriptionSucceeded && retries < 5) {
-			await this.fetchIfUnloaded();
-			subscriptionSucceeded = this.didSubscriptionSucceed();
-			retries++;
-		}
-
-		if (subscriptionSucceeded) {
+		await this.fetchIfUnloaded();
+		if (this.doAccountsExist()) {
 			this.eventEmitter.emit('update');
 		}
 
-		this.isSubscribed = subscriptionSucceeded;
-		return subscriptionSucceeded;
+		this.isSubscribed = true;
+		return true;
 	}
 
 	async addToAccountLoader(): Promise<void> {
@@ -124,7 +117,7 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		}
 	}
 
-	didSubscriptionSucceed(): boolean {
+	doAccountsExist(): boolean {
 		let success = true;
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			if (!this[accountToPoll.key]) {

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -0,0 +1,166 @@
+import {
+	DataAndSlot,
+	AccountToPoll,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} 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 { UserStatsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { capitalize } from './utils';
+
+export class PollingUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	accountsToPoll = new Map<string, AccountToPoll>();
+	errorCallbackId?: string;
+
+	userStats?: DataAndSlot<UserStatsAccount>;
+
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		await this.addToAccountLoader();
+
+		await this.fetchIfUnloaded();
+
+		if (this.doAccountsExist()) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.accountsToPoll.size > 0) {
+			return;
+		}
+
+		this.accountsToPoll.set(this.userStatsAccountPublicKey.toString(), {
+			key: 'userStats',
+			publicKey: this.userStatsAccountPublicKey,
+			eventType: 'userStatsAccountUpdate',
+		});
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			accountToPoll.callbackId = this.accountLoader.addAccount(
+				accountToPoll.publicKey,
+				(buffer, slot) => {
+					if (!buffer) {
+						return;
+					}
+
+					const account = this.program.account[
+						accountToPoll.key
+					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+					this[accountToPoll.key] = { data: account, slot };
+					// @ts-ignore
+					this.eventEmitter.emit(accountToPoll.eventType, account);
+					this.eventEmitter.emit('update');
+				}
+			);
+		}
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		let shouldFetch = false;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (this[accountToPoll.key] === undefined) {
+				shouldFetch = true;
+				break;
+			}
+		}
+
+		if (shouldFetch) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+				accountToPoll.publicKey
+			);
+			if (buffer) {
+				const account = this.program.account[
+					accountToPoll.key
+				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+				this[accountToPoll.key] = { data: account, slot };
+			}
+		}
+	}
+
+	doAccountsExist(): boolean {
+		let success = true;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (!this[accountToPoll.key]) {
+				success = false;
+				break;
+			}
+		}
+		return success;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			this.accountLoader.removeAccount(
+				accountToPoll.publicKey,
+				accountToPoll.callbackId
+			);
+		}
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.accountsToPoll.clear();
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		this.assertIsSubscribed();
+		return this.userStats;
+	}
+}

package/src/accounts/types.ts

@@ -1,16 +1,16 @@
 import {
-	BankAccount,
-	MarketAccount,
+	SpotMarketAccount,
+	PerpMarketAccount,
 	OracleSource,
 	StateAccount,
 	UserAccount,
+	UserStatsAccount,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { AccountInfo } from '@solana/spl-token';
 import { OracleInfo, OraclePriceData } from '..';
-import { BN } from '@project-serum/anchor';
 
 export interface AccountSubscriber<T> {
 	dataAndSlot?: DataAndSlot<T>;
@@ -23,34 +23,37 @@ export class NotSubscribedError extends Error {
 	name = 'NotSubscribedError';
 }
 
-export interface ClearingHouseAccountEvents {
+export interface DriftClientAccountEvents {
 	stateAccountUpdate: (payload: StateAccount) => void;
-	marketAccountUpdate: (payload: MarketAccount) => void;
-	bankAccountUpdate: (payload: BankAccount) => void;
+	perpMarketAccountUpdate: (payload: PerpMarketAccount) => void;
+	spotMarketAccountUpdate: (payload: SpotMarketAccount) => void;
 	oraclePriceUpdate: (publicKey: PublicKey, data: OraclePriceData) => void;
 	userAccountUpdate: (payload: UserAccount) => void;
 	update: void;
 	error: (e: Error) => void;
 }
 
-export interface ClearingHouseAccountSubscriber {
-	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+export interface DriftClientAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
 	isSubscribed: boolean;
 
 	subscribe(): Promise<boolean>;
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	addMarket(marketIndex: BN): Promise<boolean>;
-	addBank(bankIndex: BN): Promise<boolean>;
+	addPerpMarket(marketIndex: number): Promise<boolean>;
+	addSpotMarket(marketIndex: number): Promise<boolean>;
 	addOracle(oracleInfo: OracleInfo): Promise<boolean>;
 
 	getStateAccountAndSlot(): DataAndSlot<StateAccount>;
 	getMarketAccountAndSlot(
-		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined;
-	getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-	getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+		marketIndex: number
+	): DataAndSlot<PerpMarketAccount> | undefined;
+	getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+	getSpotMarketAccountAndSlot(
+		marketIndex: number
+	): DataAndSlot<SpotMarketAccount> | undefined;
+	getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
 	getOraclePriceDataAndSlot(
 		oraclePublicKey: PublicKey
 	): DataAndSlot<OraclePriceData> | undefined;
@@ -96,7 +99,7 @@ export interface OracleEvents {
 	error: (e: Error) => void;
 }
 
-export interface OracleSubscriber {
+export interface OracleAccountSubscriber {
 	eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
 	isSubscribed: boolean;
 
@@ -130,3 +133,20 @@ export type DataAndSlot<T> = {
 	data: T;
 	slot: number;
 };
+
+export interface UserStatsAccountEvents {
+	userStatsAccountUpdate: (payload: UserStatsAccount) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface UserStatsAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}