@drift-labs/sdk 0.1.19-master.1 → 0.1.21-master.3

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -0,0 +1,194 @@
+import {
+	AccountToPoll,
+	NotSubscribedError,
+	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 {
+	getUserAccountPublicKey,
+	getUserOrdersAccountPublicKey,
+} from '../addresses';
+import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { capitalize } from './utils';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
+
+export class PollingUserAccountSubscriber implements UserAccountSubscriber {
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+	authority: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	accountsToPoll = new Map<string, AccountToPoll>();
+	errorCallbackId?: string;
+
+	user?: UserAccount;
+	userPositions?: UserPositionsAccount;
+	userOrders?: UserOrdersAccount;
+
+	type: ClearingHouseConfigType = 'polling';
+
+	public constructor(
+		program: Program,
+		authority: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.authority = authority;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		await this.addToAccountLoader();
+		await this.fetchIfUnloaded();
+		this.eventEmitter.emit('update');
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.accountsToPoll.size > 0) {
+			return;
+		}
+
+		const userPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority
+		);
+
+		const userAccount = (await this.program.account.user.fetch(
+			userPublicKey
+		)) as UserAccount;
+
+		this.accountsToPoll.set(userPublicKey.toString(), {
+			key: 'user',
+			publicKey: userPublicKey,
+			eventType: 'userAccountData',
+		});
+
+		this.accountsToPoll.set(userAccount.positions.toString(), {
+			key: 'userPositions',
+			publicKey: userAccount.positions,
+			eventType: 'userPositionsData',
+		});
+
+		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
+			this.program.programId,
+			userPublicKey
+		);
+
+		const userOrdersExist =
+			(
+				await this.program.provider.connection.getParsedAccountInfo(
+					userOrdersPublicKey
+				)
+			).value !== null;
+		if (userOrdersExist) {
+			this.accountsToPoll.set(userOrdersPublicKey.toString(), {
+				key: 'userOrders',
+				publicKey: userOrdersPublicKey,
+				eventType: 'userOrdersData',
+			});
+		}
+
+		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');
+				}
+			);
+		}
+
+		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 = this.accountLoader.getAccountData(accountToPoll.publicKey);
+			if (buffer) {
+				this[accountToPoll.key] = this.program.account[
+					accountToPoll.key
+				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+			}
+		}
+	}
+
+	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 getUserAccount(): UserAccount {
+		this.assertIsSubscribed();
+		return this.user;
+	}
+
+	public getUserPositionsAccount(): UserPositionsAccount {
+		this.assertIsSubscribed();
+		return this.userPositions;
+	}
+
+	public getUserOrdersAccount(): UserOrdersAccount {
+		this.assertIsSubscribed();
+		return this.userOrders;
+	}
+}

package/src/accounts/types.ts

@@ -5,13 +5,19 @@ import {
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
 	MarketsAccount,
+	OrderHistoryAccount,
+	OrderStateAccount,
 	StateAccount,
 	TradeHistoryAccount,
 	UserAccount,
+	UserOrdersAccount,
 	UserPositionsAccount,
 } 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 { ClearingHouseConfigType, ClearingHouseUserConfigType } from '..';
 
 export interface AccountSubscriber<T> {
 	data?: T;
@@ -35,7 +41,10 @@ export interface ClearingHouseAccountEvents {
 	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
 	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
 	curveHistoryAccountUpdate: (payload: ExtendedCurveHistoryAccount) => void;
+	orderHistoryAccountUpdate: (payload: OrderHistoryAccount) => void;
+	orderStateAccountUpdate: (payload: OrderStateAccount) => void;
 	update: void;
+	error: (e: Error) => void;
 }
 
 export type ClearingHouseAccountTypes =
@@ -44,7 +53,8 @@ export type ClearingHouseAccountTypes =
 	| 'fundingPaymentHistoryAccount'
 	| 'fundingRateHistoryAccount'
 	| 'curveHistoryAccount'
-	| 'liquidationHistoryAccount';
+	| 'liquidationHistoryAccount'
+	| 'orderHistoryAccount';
 
 export interface ClearingHouseAccountSubscriber {
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -66,12 +76,18 @@ export interface ClearingHouseAccountSubscriber {
 	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
 	getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
 	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
+	getOrderStateAccount(): OrderStateAccount;
+	getOrderHistoryAccount(): OrderHistoryAccount;
+
+	type: ClearingHouseConfigType;
 }
 
 export interface UserAccountEvents {
 	userAccountData: (payload: UserAccount) => void;
 	userPositionsData: (payload: UserPositionsAccount) => void;
+	userOrdersData: (payload: UserOrdersAccount) => void;
 	update: void;
+	error: (e: Error) => void;
 }
 
 export interface UserAccountSubscriber {
@@ -84,4 +100,35 @@ export interface UserAccountSubscriber {
 
 	getUserAccount(): UserAccount;
 	getUserPositionsAccount(): UserPositionsAccount;
+	getUserOrdersAccount(): UserOrdersAccount;
+	type: ClearingHouseUserConfigType;
+}
+
+export interface TokenAccountEvents {
+	tokenAccountUpdate: (payload: AccountInfo) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface TokenAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, TokenAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getTokenAccount(): AccountInfo;
 }
+
+export type AccountToPoll = {
+	key: string;
+	publicKey: PublicKey;
+	eventType: string;
+	callbackId?: string;
+};
+
+export type AccountData = {
+	slot: number;
+	buffer: Buffer | undefined;
+};

package/src/accounts/utils.ts

@@ -0,0 +1,3 @@
+export function capitalize(value: string): string {
+	return value[0].toUpperCase() + value.slice(1);
+}

package/src/accounts/webSocketAccountSubscriber.ts

@@ -1,13 +1,17 @@
-import { AccountSubscriber } from './types';
+import { AccountData, AccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
-import { PublicKey } from '@solana/web3.js';
+import { AccountInfo, Context, PublicKey } from '@solana/web3.js';
+import { capitalize } from './utils';
+import * as Buffer from 'buffer';
 
 export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	data?: T;
+	accountData?: AccountData;
 	accountName: string;
 	program: Program;
 	accountPublicKey: PublicKey;
 	onChange: (data: T) => void;
+	listenerId?: number;
 
 	public constructor(
 		accountName: string,
@@ -20,32 +24,78 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
 		this.onChange = onChange;
 		await this.fetch();
 
-		this.program.account[this.accountName]
-			.subscribe(this.accountPublicKey, this.program.provider.opts.commitment)
-			.on('change', async (data: T) => {
-				this.data = data;
-				this.onChange(data);
-			});
+		this.listenerId = this.program.provider.connection.onAccountChange(
+			this.accountPublicKey,
+			(accountInfo, context) => {
+				this.handleRpcResponse(context, accountInfo);
+			},
+			this.program.provider.opts.commitment
+		);
 	}
 
 	async fetch(): Promise<void> {
-		const newData = (await this.program.account[this.accountName].fetch(
-			this.accountPublicKey
-		)) as T;
+		const rpcResponse =
+			await this.program.provider.connection.getAccountInfoAndContext(
+				this.accountPublicKey,
+				this.program.provider.opts.commitment
+			);
+		this.handleRpcResponse(rpcResponse.context, rpcResponse?.value);
+	}
+
+	handleRpcResponse(context: Context, accountInfo?: AccountInfo<Buffer>): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (accountInfo) {
+			newBuffer = accountInfo.data;
+		}
 
-		// if data has changed trigger update
-		if (JSON.stringify(newData) !== JSON.stringify(this.data)) {
-			this.data = newData;
+		if (!this.accountData) {
+			this.accountData = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				this.data = this.program.account[
+					this.accountName
+				].coder.accounts.decode(capitalize(this.accountName), newBuffer);
+				this.onChange(this.data);
+			}
+			return;
+		}
+
+		if (newSlot <= this.accountData.slot) {
+			return;
+		}
+
+		const oldBuffer = this.accountData.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.accountData = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			this.data = this.program.account[this.accountName].coder.accounts.decode(
+				capitalize(this.accountName),
+				newBuffer
+			);
 			this.onChange(this.data);
 		}
 	}
 
 	unsubscribe(): Promise<void> {
-		return this.program.account[this.accountName].unsubscribe(
-			this.accountPublicKey
-		);
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
 	}
 }

package/src/accounts/{defaultClearingHouseAccountSubscriber.ts → webSocketClearingHouseAccountSubscriber.ts}

@@ -11,6 +11,8 @@ import {
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
 	MarketsAccount,
+	OrderHistoryAccount,
+	OrderStateAccount,
 	StateAccount,
 	TradeHistoryAccount,
 } from '../types';
@@ -19,8 +21,9 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { getClearingHouseStateAccountPublicKey } from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
 
-export class DefaultClearingHouseAccountSubscriber
+export class WebSocketClearingHouseAccountSubscriber
 	implements ClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
@@ -34,9 +37,13 @@ export class DefaultClearingHouseAccountSubscriber
 	fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
 	curveHistoryAccountSubscriber?: AccountSubscriber<ExtendedCurveHistoryAccount>;
 	liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
+	orderStateAccountSubscriber?: AccountSubscriber<OrderStateAccount>;
+	orderHistoryAccountSubscriber?: AccountSubscriber<OrderHistoryAccount>;
 
 	optionalExtraSubscriptions: ClearingHouseAccountTypes[] = [];
 
+	type: ClearingHouseConfigType = 'websocket';
+
 	private isSubscribing = false;
 	private subscriptionPromise: Promise<boolean>;
 	private subscriptionPromiseResolver: (val: boolean) => void;
@@ -92,6 +99,21 @@ export class DefaultClearingHouseAccountSubscriber
 			this.eventEmitter.emit('update');
 		});
 
+		this.orderStateAccountSubscriber = new WebSocketAccountSubscriber(
+			'orderState',
+			this.program,
+			state.orderState
+		);
+
+		await this.orderStateAccountSubscriber.subscribe(
+			(data: OrderStateAccount) => {
+				this.eventEmitter.emit('orderStateAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		const orderState = this.orderStateAccountSubscriber.data;
+
 		// create subscribers for other state accounts
 
 		this.tradeHistoryAccountSubscriber = new WebSocketAccountSubscriber(
@@ -131,6 +153,12 @@ export class DefaultClearingHouseAccountSubscriber
 			state.extendedCurveHistory
 		);
 
+		this.orderHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'orderHistory',
+			this.program,
+			orderState.orderHistory
+		);
+
 		const extraSusbcribersToUse: {
 			subscriber: AccountSubscriber<any>;
 			eventType: keyof ClearingHouseAccountEvents;
@@ -172,6 +200,12 @@ export class DefaultClearingHouseAccountSubscriber
 				eventType: 'curveHistoryAccountUpdate',
 			});
 
+		if (optionalSubscriptions?.includes('orderHistoryAccount'))
+			extraSusbcribersToUse.push({
+				subscriber: this.orderHistoryAccountSubscriber,
+				eventType: 'orderHistoryAccountUpdate',
+			});
+
 		this.optionalExtraSubscriptions = optionalSubscriptions ?? [];
 
 		// await all subcriptions in parallel to boost performance
@@ -219,6 +253,7 @@ export class DefaultClearingHouseAccountSubscriber
 
 		await this.stateAccountSubscriber.unsubscribe();
 		await this.marketsAccountSubscriber.unsubscribe();
+		await this.orderStateAccountSubscriber.unsubscribe();
 
 		if (this.optionalExtraSubscriptions.includes('tradeHistoryAccount')) {
 			await this.tradeHistoryAccountSubscriber.unsubscribe();
@@ -246,6 +281,10 @@ export class DefaultClearingHouseAccountSubscriber
 			await this.liquidationHistoryAccountSubscriber.unsubscribe();
 		}
 
+		if (this.optionalExtraSubscriptions.includes('orderHistoryAccount')) {
+			await this.orderHistoryAccountSubscriber.unsubscribe();
+		}
+
 		this.isSubscribed = false;
 	}
 
@@ -318,4 +357,15 @@ export class DefaultClearingHouseAccountSubscriber
 		this.assertOptionalIsSubscribed('liquidationHistoryAccount');
 		return this.liquidationHistoryAccountSubscriber.data;
 	}
+
+	public getOrderHistoryAccount(): OrderHistoryAccount {
+		this.assertIsSubscribed();
+		this.assertOptionalIsSubscribed('orderHistoryAccount');
+		return this.orderHistoryAccountSubscriber.data;
+	}
+
+	public getOrderStateAccount(): OrderStateAccount {
+		this.assertIsSubscribed();
+		return this.orderStateAccountSubscriber.data;
+	}
 }

package/src/accounts/{defaultUserAccountSubscriber.ts → webSocketUserAccountSubscriber.ts}

@@ -8,11 +8,15 @@ 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 } from '../addresses';
+import {
+	getUserAccountPublicKey,
+	getUserOrdersAccountPublicKey,
+} from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { UserAccount, UserPositionsAccount } from '../types';
+import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
 
-export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
+export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
@@ -20,6 +24,9 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 	userPositionsAccountSubscriber: AccountSubscriber<UserPositionsAccount>;
+	userOrdersAccountSubscriber: AccountSubscriber<UserOrdersAccount>;
+
+	type: ClearingHouseConfigType = 'websocket';
 
 	public constructor(program: Program, authority: PublicKey) {
 		this.isSubscribed = false;
@@ -61,6 +68,23 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 			}
 		);
 
+		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;
@@ -70,6 +94,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		await Promise.all([
 			this.userDataAccountSubscriber.fetch(),
 			this.userPositionsAccountSubscriber.fetch(),
+			this.userOrdersAccountSubscriber.fetch(),
 		]);
 	}
 
@@ -81,6 +106,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		await Promise.all([
 			this.userDataAccountSubscriber.unsubscribe(),
 			this.userPositionsAccountSubscriber.unsubscribe(),
+			await this.userOrdersAccountSubscriber.unsubscribe(),
 		]);
 
 		this.isSubscribed = false;
@@ -103,4 +129,8 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		this.assertIsSubscribed();
 		return this.userPositionsAccountSubscriber.data;
 	}
+
+	public getUserOrdersAccount(): UserOrdersAccount {
+		return this.userOrdersAccountSubscriber.data;
+	}
 }

package/src/addresses.ts

@@ -10,6 +10,21 @@ export async function getClearingHouseStateAccountPublicKeyAndNonce(
 	);
 }
 
+export async function getOrderStateAccountPublicKey(
+	programId: PublicKey
+): Promise<PublicKey> {
+	return (await getOrderStateAccountPublicKeyAndNonce(programId))[0];
+}
+
+export async function getOrderStateAccountPublicKeyAndNonce(
+	programId: PublicKey
+): Promise<[PublicKey, number]> {
+	return anchor.web3.PublicKey.findProgramAddress(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('order_state'))],
+		programId
+	);
+}
+
 export async function getClearingHouseStateAccountPublicKey(
 	programId: PublicKey
 ): Promise<PublicKey> {
@@ -32,3 +47,25 @@ export async function getUserAccountPublicKey(
 ): Promise<PublicKey> {
 	return (await getUserAccountPublicKeyAndNonce(programId, authority))[0];
 }
+
+export async function getUserOrdersAccountPublicKeyAndNonce(
+	programId: PublicKey,
+	userAccount: PublicKey
+): Promise<[PublicKey, number]> {
+	return anchor.web3.PublicKey.findProgramAddress(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('user_orders')),
+			userAccount.toBuffer(),
+		],
+		programId
+	);
+}
+
+export async function getUserOrdersAccountPublicKey(
+	programId: PublicKey,
+	userAccount: PublicKey
+): Promise<PublicKey> {
+	return (
+		await getUserOrdersAccountPublicKeyAndNonce(programId, userAccount)
+	)[0];
+}