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

package/src/userMap/userStatsMap.ts

@@ -0,0 +1,218 @@
+import {
+	DriftClient,
+	getUserStatsAccountPublicKey,
+	OrderRecord,
+	UserStatsAccount,
+	UserStats,
+	WrappedEvent,
+	DepositRecord,
+	FundingPaymentRecord,
+	LiquidationRecord,
+	OrderActionRecord,
+	SettlePnlRecord,
+	NewUserRecord,
+	LPRecord,
+	InsuranceFundStakeRecord,
+	BulkAccountLoader,
+	PollingUserStatsAccountSubscriber,
+} from '..';
+import { PublicKey } from '@solana/web3.js';
+
+import { UserMap } from './userMap';
+
+export class UserStatsMap {
+	/**
+	 * map from authority pubkey to UserStats
+	 */
+	private userStatsMap = new Map<string, UserStats>();
+	private driftClient: DriftClient;
+	private bulkAccountLoader: BulkAccountLoader;
+
+	/**
+	 * Creates a new UserStatsMap instance.
+	 *
+	 * @param {DriftClient} driftClient - The DriftClient instance.
+	 * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+	 */
+	constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader) {
+		this.driftClient = driftClient;
+		if (!bulkAccountLoader) {
+			bulkAccountLoader = new BulkAccountLoader(
+				driftClient.connection,
+				driftClient.opts.commitment,
+				0
+			);
+		}
+		this.bulkAccountLoader = bulkAccountLoader;
+	}
+
+	public async subscribe(authorities: PublicKey[]) {
+		if (this.size() > 0) {
+			return;
+		}
+
+		await this.driftClient.subscribe();
+		await this.sync(authorities);
+	}
+
+	/**
+	 *
+	 * @param authority that owns the UserStatsAccount
+	 * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+	 * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+	 */
+	public async addUserStat(
+		authority: PublicKey,
+		userStatsAccount?: UserStatsAccount,
+		skipFetch?: boolean
+	) {
+		const userStat = new UserStats({
+			driftClient: this.driftClient,
+			userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+				this.driftClient.program.programId,
+				authority
+			),
+			accountSubscription: {
+				type: 'polling',
+				accountLoader: this.bulkAccountLoader,
+			},
+		});
+		if (skipFetch) {
+			await (
+				userStat.accountSubscriber as PollingUserStatsAccountSubscriber
+			).addToAccountLoader();
+		} else {
+			await userStat.subscribe(userStatsAccount);
+		}
+
+		this.userStatsMap.set(authority.toString(), userStat);
+	}
+
+	public async updateWithOrderRecord(record: OrderRecord, userMap: UserMap) {
+		const user = await userMap.mustGet(record.user.toString());
+		if (!this.has(user.getUserAccount().authority.toString())) {
+			await this.addUserStat(user.getUserAccount().authority, undefined, false);
+		}
+	}
+
+	public async updateWithEventRecord(
+		record: WrappedEvent<any>,
+		userMap?: UserMap
+	) {
+		if (record.eventType === 'DepositRecord') {
+			const depositRecord = record as DepositRecord;
+			await this.mustGet(depositRecord.userAuthority.toString());
+		} else if (record.eventType === 'FundingPaymentRecord') {
+			const fundingPaymentRecord = record as FundingPaymentRecord;
+			await this.mustGet(fundingPaymentRecord.userAuthority.toString());
+		} else if (record.eventType === 'LiquidationRecord') {
+			if (!userMap) {
+				return;
+			}
+
+			const liqRecord = record as LiquidationRecord;
+
+			const user = await userMap.mustGet(liqRecord.user.toString());
+			await this.mustGet(user.getUserAccount().authority.toString());
+
+			const liquidatorUser = await userMap.mustGet(
+				liqRecord.liquidator.toString()
+			);
+			await this.mustGet(liquidatorUser.getUserAccount().authority.toString());
+		} else if (record.eventType === 'OrderRecord') {
+			if (!userMap) {
+				return;
+			}
+			const orderRecord = record as OrderRecord;
+			await userMap.updateWithOrderRecord(orderRecord);
+		} else if (record.eventType === 'OrderActionRecord') {
+			if (!userMap) {
+				return;
+			}
+			const actionRecord = record as OrderActionRecord;
+
+			if (actionRecord.taker) {
+				const taker = await userMap.mustGet(actionRecord.taker.toString());
+				await this.mustGet(taker.getUserAccount().authority.toString());
+			}
+			if (actionRecord.maker) {
+				const maker = await userMap.mustGet(actionRecord.maker.toString());
+				await this.mustGet(maker.getUserAccount().authority.toString());
+			}
+		} else if (record.eventType === 'SettlePnlRecord') {
+			if (!userMap) {
+				return;
+			}
+			const settlePnlRecord = record as SettlePnlRecord;
+			const user = await userMap.mustGet(settlePnlRecord.user.toString());
+			await this.mustGet(user.getUserAccount().authority.toString());
+		} else if (record.eventType === 'NewUserRecord') {
+			const newUserRecord = record as NewUserRecord;
+			await this.mustGet(newUserRecord.userAuthority.toString());
+		} else if (record.eventType === 'LPRecord') {
+			if (!userMap) {
+				return;
+			}
+			const lpRecord = record as LPRecord;
+			const user = await userMap.mustGet(lpRecord.user.toString());
+			await this.mustGet(user.getUserAccount().authority.toString());
+		} else if (record.eventType === 'InsuranceFundStakeRecord') {
+			const ifStakeRecord = record as InsuranceFundStakeRecord;
+			await this.mustGet(ifStakeRecord.userAuthority.toString());
+		}
+	}
+
+	public has(authorityPublicKey: string): boolean {
+		return this.userStatsMap.has(authorityPublicKey);
+	}
+
+	public get(authorityPublicKey: string): UserStats {
+		return this.userStatsMap.get(authorityPublicKey);
+	}
+
+	/**
+	 * Enforce that a UserStats will exist for the given authorityPublicKey,
+	 * reading one from the blockchain if necessary.
+	 * @param authorityPublicKey
+	 * @returns
+	 */
+	public async mustGet(authorityPublicKey: string): Promise<UserStats> {
+		if (!this.has(authorityPublicKey)) {
+			await this.addUserStat(
+				new PublicKey(authorityPublicKey),
+				undefined,
+				false
+			);
+		}
+		return this.get(authorityPublicKey);
+	}
+
+	public values(): IterableIterator<UserStats> {
+		return this.userStatsMap.values();
+	}
+
+	public size(): number {
+		return this.userStatsMap.size;
+	}
+
+	/**
+	 * Sync the UserStatsMap
+	 * @param authorities list of authorities to derive UserStatsAccount public keys from.
+	 * You may want to get this list from UserMap in order to filter out idle users
+	 */
+	public async sync(authorities: PublicKey[]) {
+		await Promise.all(
+			authorities.map((authority) =>
+				this.addUserStat(authority, undefined, true)
+			)
+		);
+		await this.bulkAccountLoader.load();
+	}
+
+	public async unsubscribe() {
+		for (const [key, userStats] of this.userStatsMap.entries()) {
+			await userStats.unsubscribe();
+			this.userStatsMap.delete(key);
+		}
+	}
+}

package/src/userName.ts

@@ -0,0 +1,21 @@
+export const MAX_NAME_LENGTH = 32;
+
+export const DEFAULT_USER_NAME = 'Main Account';
+export const DEFAULT_MARKET_NAME = 'Default Market Name';
+
+export function encodeName(name: string): number[] {
+	if (name.length > MAX_NAME_LENGTH) {
+		throw Error(`Name (${name}) longer than 32 characters`);
+	}
+
+	const buffer = Buffer.alloc(32);
+	buffer.fill(name);
+	buffer.fill(' ', name.length);
+
+	return Array(...buffer);
+}
+
+export function decodeName(bytes: number[]): string {
+	const buffer = Buffer.from(bytes);
+	return buffer.toString('utf8').trim();
+}

package/src/userStats.ts

@@ -0,0 +1,174 @@
+import { DriftClient } from './driftClient';
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot, UserStatsAccountSubscriber } from './accounts/types';
+import { UserStatsConfig } from './userStatsConfig';
+import { PollingUserStatsAccountSubscriber } from './accounts/pollingUserStatsAccountSubscriber';
+import { WebSocketUserStatsAccountSubscriber } from './accounts/webSocketUserStatsAccountSubsriber';
+import { ReferrerInfo, SpotMarketAccount, UserStatsAccount } from './types';
+import {
+	getUserAccountPublicKeySync,
+	getUserStatsAccountPublicKey,
+} from './addresses/pda';
+import { grpcUserStatsAccountSubscriber } from './accounts/grpcUserStatsAccountSubscriber';
+import { FUEL_START_TS } from './constants/numericConstants';
+import { ZERO } from './constants/numericConstants';
+import {
+	GOV_SPOT_MARKET_INDEX,
+	QUOTE_SPOT_MARKET_INDEX,
+} from './constants/numericConstants';
+import { BN } from '@coral-xyz/anchor';
+import { calculateInsuranceFuelBonus } from './math/fuel';
+
+export class UserStats {
+	driftClient: DriftClient;
+	userStatsAccountPublicKey: PublicKey;
+	accountSubscriber: UserStatsAccountSubscriber;
+	isSubscribed: boolean;
+
+	public constructor(config: UserStatsConfig) {
+		this.driftClient = config.driftClient;
+		this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
+		if (config.accountSubscription?.type === 'polling') {
+			this.accountSubscriber = new PollingUserStatsAccountSubscriber(
+				config.driftClient.program,
+				config.userStatsAccountPublicKey,
+				config.accountSubscription.accountLoader
+			);
+		} else if (config.accountSubscription?.type === 'grpc') {
+			this.accountSubscriber = new grpcUserStatsAccountSubscriber(
+				config.accountSubscription.grpcConfigs,
+				config.driftClient.program,
+				config.userStatsAccountPublicKey,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				}
+			);
+		} else if (config.accountSubscription?.type === 'websocket') {
+			this.accountSubscriber = new WebSocketUserStatsAccountSubscriber(
+				config.driftClient.program,
+				config.userStatsAccountPublicKey,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				},
+				config.accountSubscription.commitment
+			);
+		} else {
+			throw new Error(
+				`Unknown user stats account subscription type: ${config.accountSubscription?.type}`
+			);
+		}
+	}
+
+	public async subscribe(
+		userStatsAccount?: UserStatsAccount
+	): Promise<boolean> {
+		this.isSubscribed = await this.accountSubscriber.subscribe(
+			userStatsAccount
+		);
+		return this.isSubscribed;
+	}
+
+	public async fetchAccounts(): Promise<void> {
+		await this.accountSubscriber.fetch();
+	}
+
+	public async unsubscribe(): Promise<void> {
+		await this.accountSubscriber.unsubscribe();
+		this.isSubscribed = false;
+	}
+
+	public getAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		return this.accountSubscriber.getUserStatsAccountAndSlot();
+	}
+
+	public getAccount(): UserStatsAccount {
+		return this.accountSubscriber.getUserStatsAccountAndSlot().data;
+	}
+
+	public getInsuranceFuelBonus(
+		now: BN,
+		includeSettled = true,
+		includeUnsettled = true
+	): BN {
+		const userStats: UserStatsAccount = this.getAccount();
+
+		let insuranceFuel = ZERO;
+
+		if (includeSettled) {
+			insuranceFuel = insuranceFuel.add(new BN(userStats.fuelInsurance));
+		}
+
+		if (includeUnsettled) {
+			// todo: get real time ifStakedGovTokenAmount using ifStakeAccount
+			if (userStats.ifStakedGovTokenAmount.gt(ZERO)) {
+				const spotMarketAccount: SpotMarketAccount =
+					this.driftClient.getSpotMarketAccount(GOV_SPOT_MARKET_INDEX);
+
+				const fuelBonusNumeratorUserStats = BN.max(
+					now.sub(
+						BN.max(new BN(userStats.lastFuelIfBonusUpdateTs), FUEL_START_TS)
+					),
+					ZERO
+				);
+
+				insuranceFuel = insuranceFuel.add(
+					calculateInsuranceFuelBonus(
+						spotMarketAccount,
+						userStats.ifStakedGovTokenAmount,
+						fuelBonusNumeratorUserStats
+					)
+				);
+			}
+
+			if (userStats.ifStakedQuoteAssetAmount.gt(ZERO)) {
+				const spotMarketAccount: SpotMarketAccount =
+					this.driftClient.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX);
+
+				const fuelBonusNumeratorUserStats = BN.max(
+					now.sub(
+						BN.max(new BN(userStats.lastFuelIfBonusUpdateTs), FUEL_START_TS)
+					),
+					ZERO
+				);
+
+				insuranceFuel = insuranceFuel.add(
+					calculateInsuranceFuelBonus(
+						spotMarketAccount,
+						userStats.ifStakedQuoteAssetAmount,
+						fuelBonusNumeratorUserStats
+					)
+				);
+			}
+		}
+
+		return insuranceFuel;
+	}
+
+	public getReferrerInfo(): ReferrerInfo | undefined {
+		if (this.getAccount().referrer.equals(PublicKey.default)) {
+			return undefined;
+		} else {
+			return {
+				referrer: getUserAccountPublicKeySync(
+					this.driftClient.program.programId,
+					this.getAccount().referrer,
+					0
+				),
+				referrerStats: getUserStatsAccountPublicKey(
+					this.driftClient.program.programId,
+					this.getAccount().referrer
+				),
+			};
+		}
+	}
+
+	public static getOldestActionTs(account: UserStatsAccount): number {
+		return Math.min(
+			account.lastFillerVolume30DTs.toNumber(),
+			account.lastMakerVolume30DTs.toNumber(),
+			account.lastTakerVolume30DTs.toNumber()
+		);
+	}
+}

package/src/userStatsConfig.ts

@@ -0,0 +1,31 @@
+import { DriftClient } from './driftClient';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { GrpcConfigs } from './accounts/types';
+
+export type UserStatsConfig = {
+	accountSubscription?: UserStatsSubscriptionConfig;
+	driftClient: DriftClient;
+	userStatsAccountPublicKey: PublicKey;
+};
+
+export type UserStatsSubscriptionConfig =
+	| {
+			type: 'websocket';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			commitment?: Commitment;
+	  }
+	| {
+			type: 'polling';
+			accountLoader: BulkAccountLoader;
+	  }
+	| {
+			type: 'custom';
+	  }
+	| {
+			type: 'grpc';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			grpcConfigs: GrpcConfigs;
+	  };