@drift-labs/sdk-browser 2.104.0-beta.21

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -0,0 +1,160 @@
+import {
+	DataAndSlot,
+	NotSubscribedError,
+	UserAccountEvents,
+	UserAccountSubscriber,
+} from './types';
+import { Connection } from '../bankrun/bankrunConnection';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+
+export class PollingUserAccountSubscriber implements UserAccountSubscriber {
+	isSubscribed: boolean;
+	connection: Connection;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+	userAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	callbackId?: string;
+	errorCallbackId?: string;
+
+	decode: (name, buffer) => UserAccount;
+
+	user?: DataAndSlot<UserAccount>;
+
+	public constructor(
+		connection: Connection,
+		userAccountPublicKey: PublicKey,
+		accountLoader: BulkAccountLoader,
+		decode: (name, buffer) => UserAccount
+	) {
+		this.isSubscribed = false;
+		this.connection = connection;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+		this.userAccountPublicKey = userAccountPublicKey;
+		this.decode = decode;
+	}
+
+	async subscribe(userAccount?: UserAccount): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		if (userAccount) {
+			this.user = { data: userAccount, slot: undefined };
+		}
+
+		await this.addToAccountLoader();
+
+		await this.fetchIfUnloaded();
+		if (this.doesAccountExist()) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.userAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
+
+				if (this.user && this.user.slot > slot) {
+					return;
+				}
+
+				const account = this.decode('User', buffer);
+				this.user = { data: account, slot };
+				this.eventEmitter.emit('userAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.user === undefined) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			const dataAndContext = await this.connection.getAccountInfoAndContext(
+				this.userAccountPublicKey,
+				this.accountLoader.commitment
+			);
+			if (dataAndContext.context.slot > (this.user?.slot ?? 0)) {
+				this.user = {
+					data: this.decode('User', dataAndContext.value.data),
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}-${e.stack}`
+			);
+		}
+	}
+
+	doesAccountExist(): boolean {
+		return this.user !== undefined;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(
+			this.userAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserAccountAndSlot(): DataAndSlot<UserAccount> {
+		if (!this.doesAccountExist()) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` or `fetch` before using this function'
+			);
+		}
+		return this.user;
+	}
+
+	public updateData(userAccount: UserAccount, slot: number): void {
+		if (!this.user || this.user.slot < slot) {
+			this.user = { data: userAccount, slot };
+			this.eventEmitter.emit('userAccountUpdate', userAccount);
+			this.eventEmitter.emit('update');
+		}
+	}
+}

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -0,0 +1,156 @@
+import {
+	DataAndSlot,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} from './types';
+import { Program } from '@coral-xyz/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';
+
+export class PollingUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	callbackId?: string;
+	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(userStatsAccount?: UserStatsAccount): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		if (userStatsAccount) {
+			this.userStats = { data: userStatsAccount, slot: undefined };
+		}
+
+		await this.addToAccountLoader();
+
+		await this.fetchIfUnloaded();
+
+		if (this.doesAccountExist()) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId !== undefined) {
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.userStatsAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
+
+				if (this.userStats && this.userStats.slot > slot) {
+					return;
+				}
+
+				const account =
+					this.program.account.userStats.coder.accounts.decodeUnchecked(
+						'UserStats',
+						buffer
+					);
+				this.userStats = { data: account, slot };
+				this.eventEmitter.emit('userStatsAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.userStats === undefined) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			const dataAndContext =
+				await this.program.account.userStats.fetchAndContext(
+					this.userStatsAccountPublicKey,
+					this.accountLoader.commitment
+				);
+			if (dataAndContext.context.slot > (this.userStats?.slot ?? 0)) {
+				this.userStats = {
+					data: dataAndContext.data as UserStatsAccount,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingUserStatsAccountSubscriber.fetch() UserStatsAccount does not exist: ${e.message}`
+			);
+		}
+	}
+
+	doesAccountExist(): boolean {
+		return this.userStats !== undefined;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(
+			this.userStatsAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		if (!this.doesAccountExist()) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` or `fetch` before using this function'
+			);
+		}
+		return this.userStats;
+	}
+}

package/src/accounts/testBulkAccountLoader.ts

@@ -0,0 +1,53 @@
+import { AccountToLoad, BulkAccountLoader } from './bulkAccountLoader';
+
+export class TestBulkAccountLoader extends BulkAccountLoader {
+	async loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void> {
+		if (accountsToLoadChunks.length === 0) {
+			return;
+		}
+
+		const accounts = [];
+		for (const accountsToLoadChunk of accountsToLoadChunks) {
+			for (const accountToLoad of accountsToLoadChunk) {
+				const account = await this.connection.getAccountInfoAndContext(
+					accountToLoad.publicKey,
+					this.commitment
+				);
+				accounts.push(account);
+				const newSlot = account.context.slot;
+				if (newSlot > this.mostRecentSlot) {
+					this.mostRecentSlot = newSlot;
+				}
+
+				if (accountToLoad.callbacks.size === 0) {
+					return;
+				}
+
+				const key = accountToLoad.publicKey.toBase58();
+				const prev = this.bufferAndSlotMap.get(key);
+
+				if (prev && newSlot < prev.slot) {
+					return;
+				}
+
+				let newBuffer: Buffer | undefined = undefined;
+
+				if (account.value) {
+					newBuffer = account.value.data;
+				}
+
+				if (!prev) {
+					this.bufferAndSlotMap.set(key, { slot: newSlot, buffer: newBuffer });
+					this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+					return;
+				}
+
+				const oldBuffer = prev.buffer;
+				if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+					this.bufferAndSlotMap.set(key, { slot: newSlot, buffer: newBuffer });
+					this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+				}
+			}
+		}
+	}
+}

package/src/accounts/types.ts

@@ -0,0 +1,245 @@
+import {
+	SpotMarketAccount,
+	PerpMarketAccount,
+	OracleSource,
+	StateAccount,
+	UserAccount,
+	UserStatsAccount,
+	InsuranceFundStake,
+} from '../types';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Context, PublicKey } from '@solana/web3.js';
+import { Account } from '@solana/spl-token';
+import { HighLeverageModeConfig, OracleInfo, OraclePriceData } from '..';
+import { ChannelOptions, CommitmentLevel } from '../isomorphic/grpc';
+
+export interface AccountSubscriber<T> {
+	dataAndSlot?: DataAndSlot<T>;
+	subscribe(onChange: (data: T) => void): Promise<void>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	setData(userAccount: T, slot?: number): void;
+}
+
+export interface ProgramAccountSubscriber<T> {
+	subscribe(
+		onChange: (
+			accountId: PublicKey,
+			data: T,
+			context: Context,
+			buffer: Buffer
+		) => void
+	): Promise<void>;
+	unsubscribe(): Promise<void>;
+}
+
+export class NotSubscribedError extends Error {
+	name = 'NotSubscribedError';
+}
+
+export interface DriftClientAccountEvents {
+	stateAccountUpdate: (payload: StateAccount) => void;
+	perpMarketAccountUpdate: (payload: PerpMarketAccount) => void;
+	spotMarketAccountUpdate: (payload: SpotMarketAccount) => void;
+	oraclePriceUpdate: (
+		publicKey: PublicKey,
+		oracleSource: OracleSource,
+		data: OraclePriceData
+	) => void;
+	userAccountUpdate: (payload: UserAccount) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface DriftClientAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	addPerpMarket(marketIndex: number): Promise<boolean>;
+	addSpotMarket(marketIndex: number): Promise<boolean>;
+	addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+	setPerpOracleMap(): Promise<void>;
+	setSpotOracleMap(): Promise<void>;
+
+	getStateAccountAndSlot(): DataAndSlot<StateAccount>;
+	getMarketAccountAndSlot(
+		marketIndex: number
+	): DataAndSlot<PerpMarketAccount> | undefined;
+	getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+	getSpotMarketAccountAndSlot(
+		marketIndex: number
+	): DataAndSlot<SpotMarketAccount> | undefined;
+	getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
+	getOraclePriceDataAndSlot(
+		oracleId: string
+	): DataAndSlot<OraclePriceData> | undefined;
+	getOraclePriceDataAndSlotForPerpMarket(
+		marketIndex: number
+	): DataAndSlot<OraclePriceData> | undefined;
+	getOraclePriceDataAndSlotForSpotMarket(
+		marketIndex: number
+	): DataAndSlot<OraclePriceData> | undefined;
+
+	updateAccountLoaderPollingFrequency?: (pollingFrequency: number) => void;
+}
+
+export enum DelistedMarketSetting {
+	Unsubscribe,
+	Subscribe,
+	Discard,
+}
+
+export interface UserAccountEvents {
+	userAccountUpdate: (payload: UserAccount) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface UserAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(userAccount?: UserAccount): Promise<boolean>;
+	fetch(): Promise<void>;
+	updateData(userAccount: UserAccount, slot: number): void;
+	unsubscribe(): Promise<void>;
+
+	getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+}
+
+export interface TokenAccountEvents {
+	tokenAccountUpdate: (payload: Account) => 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>;
+
+	getTokenAccountAndSlot(): DataAndSlot<Account>;
+}
+
+export interface InsuranceFundStakeAccountSubscriber {
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+}
+
+export interface InsuranceFundStakeAccountEvents {
+	insuranceFundStakeAccountUpdate: (payload: InsuranceFundStake) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface OracleEvents {
+	oracleUpdate: (payload: OraclePriceData) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface OracleAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getOraclePriceData(): DataAndSlot<OraclePriceData>;
+}
+
+export type AccountToPoll = {
+	key: string;
+	publicKey: PublicKey;
+	eventType: string;
+	callbackId?: string;
+	mapKey?: number;
+};
+
+export type OraclesToPoll = {
+	publicKey: PublicKey;
+	source: OracleSource;
+	callbackId?: string;
+};
+
+export type BufferAndSlot = {
+	slot: number;
+	buffer: Buffer | undefined;
+};
+
+export type DataAndSlot<T> = {
+	data: T;
+	slot: number;
+};
+
+export type ResubOpts = {
+	resubTimeoutMs?: number;
+	logResubMessages?: boolean;
+};
+
+export interface UserStatsAccountEvents {
+	userStatsAccountUpdate: (payload: UserStatsAccount) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface UserStatsAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}
+
+export type GrpcConfigs = {
+	endpoint: string;
+	token: string;
+	commitmentLevel?: CommitmentLevel;
+	channelOptions?: ChannelOptions;
+};
+
+export interface HighLeverageModeConfigAccountSubscriber {
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		HighLeverageModeConfigAccountEvents
+	>;
+	isSubscribed: boolean;
+
+	subscribe(
+		highLeverageModeConfigAccount?: HighLeverageModeConfig
+	): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getHighLeverageModeConfigAccountAndSlot(): DataAndSlot<HighLeverageModeConfig>;
+}
+
+export interface HighLeverageModeConfigAccountEvents {
+	highLeverageModeConfigAccountUpdate: (
+		payload: HighLeverageModeConfig
+	) => void;
+	update: void;
+	error: (e: Error) => void;
+}

package/src/accounts/utils.ts

@@ -0,0 +1,62 @@
+import { DataAndSlot } from './types';
+import { isVariant, PerpMarketAccount, SpotMarketAccount } from '../types';
+import { OracleInfo } from '../oracles/types';
+import { getOracleId } from '../oracles/oracleId';
+
+export function capitalize(value: string): string {
+	return value[0].toUpperCase() + value.slice(1);
+}
+
+export function findDelistedPerpMarketsAndOracles(
+	perpMarkets: DataAndSlot<PerpMarketAccount>[],
+	spotMarkets: DataAndSlot<SpotMarketAccount>[]
+): { perpMarketIndexes: number[]; oracles: OracleInfo[] } {
+	const delistedPerpMarketIndexes = [];
+	const delistedOracles: OracleInfo[] = [];
+	for (const perpMarket of perpMarkets) {
+		if (!perpMarket.data) {
+			continue;
+		}
+
+		if (isVariant(perpMarket.data.status, 'delisted')) {
+			delistedPerpMarketIndexes.push(perpMarket.data.marketIndex);
+			delistedOracles.push({
+				publicKey: perpMarket.data.amm.oracle,
+				source: perpMarket.data.amm.oracleSource,
+			});
+		}
+	}
+
+	// make sure oracle isn't used by spot market
+	const filteredDelistedOracles = [];
+	for (const delistedOracle of delistedOracles) {
+		let isUsedBySpotMarket = false;
+		for (const spotMarket of spotMarkets) {
+			if (!spotMarket.data) {
+				continue;
+			}
+
+			const delistedOracleId = getOracleId(
+				delistedOracle.publicKey,
+				delistedOracle.source
+			);
+			const spotMarketOracleId = getOracleId(
+				spotMarket.data.oracle,
+				spotMarket.data.oracleSource
+			);
+			if (spotMarketOracleId === delistedOracleId) {
+				isUsedBySpotMarket = true;
+				break;
+			}
+		}
+
+		if (!isUsedBySpotMarket) {
+			filteredDelistedOracles.push(delistedOracle);
+		}
+	}
+
+	return {
+		perpMarketIndexes: delistedPerpMarketIndexes,
+		oracles: filteredDelistedOracles,
+	};
+}