@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.30

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -0,0 +1,172 @@
+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();
+
+		let subscriptionSucceeded = false;
+		let retries = 0;
+		while (!subscriptionSucceeded && retries < 5) {
+			await this.fetchIfUnloaded();
+			subscriptionSucceeded = this.didSubscriptionSucceed();
+			retries++;
+		}
+
+		if (subscriptionSucceeded) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = subscriptionSucceeded;
+		return subscriptionSucceeded;
+	}
+
+	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 };
+			}
+		}
+	}
+
+	didSubscriptionSucceed(): 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>;
@@ -25,8 +25,8 @@ export class NotSubscribedError extends Error {
 
 export interface ClearingHouseAccountEvents {
 	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;
@@ -41,16 +41,19 @@ export interface ClearingHouseAccountSubscriber {
 	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;
@@ -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>;
+}

package/src/accounts/webSocketClearingHouseAccountSubscriber.ts

@@ -4,13 +4,13 @@ import {
 	DataAndSlot,
 } from './types';
 import { AccountSubscriber, NotSubscribedError } from './types';
-import { BankAccount, MarketAccount, StateAccount } from '../types';
-import { BN, Program } from '@project-serum/anchor';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount } from '../types';
+import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
 	getClearingHouseStateAccountPublicKey,
-	getBankPublicKey,
+	getSpotMarketPublicKey,
 	getMarketPublicKey,
 } from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
@@ -25,18 +25,21 @@ export class WebSocketClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
-	marketIndexes: BN[];
-	bankIndexes: BN[];
+	perpMarketIndexes: number[];
+	spotMarketIndexes: number[];
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
 	stateAccountSubscriber?: AccountSubscriber<StateAccount>;
-	marketAccountSubscribers = new Map<
+	perpMarketAccountSubscribers = new Map<
 		number,
-		AccountSubscriber<MarketAccount>
+		AccountSubscriber<PerpMarketAccount>
+	>();
+	spotMarketAccountSubscribers = new Map<
+		number,
+		AccountSubscriber<SpotMarketAccount>
 	>();
-	bankAccountSubscribers = new Map<number, AccountSubscriber<BankAccount>>();
 	oracleSubscribers = new Map<string, AccountSubscriber<OraclePriceData>>();
 
 	private isSubscribing = false;
@@ -45,15 +48,15 @@ export class WebSocketClearingHouseAccountSubscriber
 
 	public constructor(
 		program: Program,
-		marketIndexes: BN[],
-		bankIndexes: BN[],
+		perpMarketIndexes: number[],
+		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[]
 	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.eventEmitter = new EventEmitter();
-		this.marketIndexes = marketIndexes;
-		this.bankIndexes = bankIndexes;
+		this.perpMarketIndexes = perpMarketIndexes;
+		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 	}
 
@@ -90,8 +93,8 @@ export class WebSocketClearingHouseAccountSubscriber
 		// subscribe to market accounts
 		await this.subscribeToMarketAccounts();
 
-		// subscribe to bank accounts
-		await this.subscribeToBankAccounts();
+		// subscribe to spot market accounts
+		await this.subscribeToSpotMarketAccounts();
 
 		// subscribe to oracles
 		await this.subscribeToOracles();
@@ -106,55 +109,52 @@ export class WebSocketClearingHouseAccountSubscriber
 	}
 
 	async subscribeToMarketAccounts(): Promise<boolean> {
-		for (const marketIndex of this.marketIndexes) {
+		for (const marketIndex of this.perpMarketIndexes) {
 			await this.subscribeToMarketAccount(marketIndex);
 		}
 		return true;
 	}
 
-	async subscribeToMarketAccount(marketIndex: BN): Promise<boolean> {
+	async subscribeToMarketAccount(marketIndex: number): Promise<boolean> {
 		const marketPublicKey = await getMarketPublicKey(
 			this.program.programId,
 			marketIndex
 		);
-		const accountSubscriber = new WebSocketAccountSubscriber<MarketAccount>(
-			'market',
+		const accountSubscriber = new WebSocketAccountSubscriber<PerpMarketAccount>(
+			'perpMarket',
 			this.program,
 			marketPublicKey
 		);
-		await accountSubscriber.subscribe((data: MarketAccount) => {
-			this.eventEmitter.emit('marketAccountUpdate', data);
+		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
+			this.eventEmitter.emit('perpMarketAccountUpdate', data);
 			this.eventEmitter.emit('update');
 		});
-		this.marketAccountSubscribers.set(
-			marketIndex.toNumber(),
-			accountSubscriber
-		);
+		this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
 		return true;
 	}
 
-	async subscribeToBankAccounts(): Promise<boolean> {
-		for (const bankIndex of this.bankIndexes) {
-			await this.subscribeToBankAccount(bankIndex);
+	async subscribeToSpotMarketAccounts(): Promise<boolean> {
+		for (const marketIndex of this.spotMarketIndexes) {
+			await this.subscribeToSpotMarketAccount(marketIndex);
 		}
 		return true;
 	}
 
-	async subscribeToBankAccount(bankIndex: BN): Promise<boolean> {
-		const bankPublicKey = await getBankPublicKey(
+	async subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean> {
+		const marketPublicKey = await getSpotMarketPublicKey(
 			this.program.programId,
-			bankIndex
+			marketIndex
 		);
-		const accountSubscriber = new WebSocketAccountSubscriber<BankAccount>(
-			'bank',
+		const accountSubscriber = new WebSocketAccountSubscriber<SpotMarketAccount>(
+			'spotMarket',
 			this.program,
-			bankPublicKey
+			marketPublicKey
 		);
-		await accountSubscriber.subscribe((data: BankAccount) => {
-			this.eventEmitter.emit('bankAccountUpdate', data);
+		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
+			this.eventEmitter.emit('spotMarketAccountUpdate', data);
 			this.eventEmitter.emit('update');
 		});
-		this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+		this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
 		return true;
 	}
 
@@ -195,13 +195,13 @@ export class WebSocketClearingHouseAccountSubscriber
 	}
 
 	async unsubscribeFromMarketAccounts(): Promise<void> {
-		for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+		for (const accountSubscriber of this.perpMarketAccountSubscribers.values()) {
 			await accountSubscriber.unsubscribe();
 		}
 	}
 
-	async unsubscribeFromBankAccounts(): Promise<void> {
-		for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+	async unsubscribeFromSpotMarketAccounts(): Promise<void> {
+		for (const accountSubscriber of this.spotMarketAccountSubscribers.values()) {
 			await accountSubscriber.unsubscribe();
 		}
 	}
@@ -219,13 +219,13 @@ export class WebSocketClearingHouseAccountSubscriber
 
 		const promises = [this.stateAccountSubscriber.fetch()]
 			.concat(
-				Array.from(this.marketAccountSubscribers.values()).map((subscriber) =>
-					subscriber.fetch()
+				Array.from(this.perpMarketAccountSubscribers.values()).map(
+					(subscriber) => subscriber.fetch()
 				)
 			)
 			.concat(
-				Array.from(this.bankAccountSubscribers.values()).map((subscriber) =>
-					subscriber.fetch()
+				Array.from(this.spotMarketAccountSubscribers.values()).map(
+					(subscriber) => subscriber.fetch()
 				)
 			);
 
@@ -240,21 +240,21 @@ export class WebSocketClearingHouseAccountSubscriber
 		await this.stateAccountSubscriber.unsubscribe();
 
 		await this.unsubscribeFromMarketAccounts();
-		await this.unsubscribeFromBankAccounts();
+		await this.unsubscribeFromSpotMarketAccounts();
 		await this.unsubscribeFromOracles();
 
 		this.isSubscribed = false;
 	}
 
-	async addBank(bankIndex: BN): Promise<boolean> {
-		if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+	async addSpotMarket(marketIndex: number): Promise<boolean> {
+		if (this.spotMarketAccountSubscribers.has(marketIndex)) {
 			return true;
 		}
-		return this.subscribeToBankAccount(bankIndex);
+		return this.subscribeToSpotMarketAccount(marketIndex);
 	}
 
-	async addMarket(marketIndex: BN): Promise<boolean> {
-		if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+	async addPerpMarket(marketIndex: number): Promise<boolean> {
+		if (this.perpMarketAccountSubscribers.has(marketIndex)) {
 			return true;
 		}
 		return this.subscribeToMarketAccount(marketIndex);
@@ -286,24 +286,29 @@ export class WebSocketClearingHouseAccountSubscriber
 	}
 
 	public getMarketAccountAndSlot(
-		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined {
+		marketIndex: number
+	): DataAndSlot<PerpMarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.marketAccountSubscribers.get(marketIndex.toNumber())
-			.dataAndSlot;
+		return this.perpMarketAccountSubscribers.get(marketIndex).dataAndSlot;
 	}
 
-	public getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[] {
-		return Array.from(this.marketAccountSubscribers.values()).map(
+	public getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[] {
+		return Array.from(this.perpMarketAccountSubscribers.values()).map(
 			(subscriber) => subscriber.dataAndSlot
 		);
 	}
 
-	public getBankAccountAndSlot(
-		bankIndex: BN
-	): DataAndSlot<BankAccount> | undefined {
+	public getSpotMarketAccountAndSlot(
+		marketIndex: number
+	): DataAndSlot<SpotMarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+		return this.spotMarketAccountSubscribers.get(marketIndex).dataAndSlot;
+	}
+
+	public getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[] {
+		return Array.from(this.spotMarketAccountSubscribers.values()).map(
+			(subscriber) => subscriber.dataAndSlot
+		);
 	}
 
 	public getOraclePriceDataAndSlot(

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -0,0 +1,80 @@
+import {
+	DataAndSlot,
+	AccountSubscriber,
+	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 { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { UserStatsAccount } from '../types';
+
+export class WebSocketUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+
+	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
+			'userStats',
+			this.program,
+			this.userStatsAccountPublicKey
+		);
+		await this.userStatsAccountSubscriber.subscribe(
+			(data: UserStatsAccount) => {
+				this.eventEmitter.emit('userStatsAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async fetch(): Promise<void> {
+		await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+
+		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.userStatsAccountSubscriber.dataAndSlot;
+	}
+}

package/src/addresses/marketAddresses.ts

@@ -1,11 +1,10 @@
 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
+	marketIndex: number
 ): Promise<PublicKey> {
 	const cacheKey = `${programId.toString()}-${marketIndex.toString()}`;
 	if (CACHE.has(cacheKey)) {