@drift-labs/sdk 2.49.0-beta.9 → 2.52.0-beta.1

package/src/math/state.ts

@@ -0,0 +1,26 @@
+import { StateAccount } from '../types';
+import { BN, LAMPORTS_PRECISION, PERCENTAGE_PRECISION, ZERO } from '../';
+
+export function calculateInitUserFee(stateAccount: StateAccount): BN {
+	const maxInitFee = new BN(stateAccount.maxInitializeUserFee)
+		.mul(LAMPORTS_PRECISION)
+		.divn(100);
+	const targetUtilization = PERCENTAGE_PRECISION.muln(8).divn(10);
+
+	const accountSpaceUtilization = stateAccount.numberOfSubAccounts
+		.addn(1)
+		.mul(PERCENTAGE_PRECISION)
+		.div(getMaxNumberOfSubAccounts(stateAccount));
+
+	if (accountSpaceUtilization.gt(targetUtilization)) {
+		return maxInitFee
+			.mul(accountSpaceUtilization.sub(targetUtilization))
+			.div(PERCENTAGE_PRECISION.sub(targetUtilization));
+	} else {
+		return ZERO;
+	}
+}
+
+export function getMaxNumberOfSubAccounts(stateAccount: StateAccount): BN {
+	return new BN(stateAccount.maxNumberOfSubAccounts).muln(100);
+}

package/src/math/superStake.ts

@@ -14,6 +14,38 @@ import { LAMPORTS_PRECISION, ZERO } from '../constants/numericConstants';
 import fetch from 'node-fetch';
 import { checkSameDate } from './utils';
 
+export type BSOL_STATS_API_RESPONSE = {
+	success: boolean;
+	stats?: {
+		conversion: {
+			bsol_to_sol: number;
+			sol_to_bsol: number;
+		};
+		apy: {
+			base: number;
+			blze: number;
+			total: number;
+			lending: number;
+			liquidity: number;
+		};
+	};
+};
+
+export type BSOL_EMISSIONS_API_RESPONSE = {
+	success: boolean;
+	emissions?: {
+		lend: number;
+	};
+};
+
+export async function fetchBSolMetrics() {
+	return await fetch('https://stake.solblaze.org/api/v1/stats');
+}
+
+export async function fetchBSolDriftEmissions() {
+	return await fetch('https://stake.solblaze.org/api/v1/drift_emissions');
+}
+
 export async function findBestSuperStakeIxs({
 	marketIndex,
 	amount,
@@ -56,6 +88,16 @@ export async function findBestSuperStakeIxs({
 			userAccountPublicKey,
 			onlyDirectRoutes,
 		});
+	} else if (marketIndex === 8) {
+		return findBestLstSuperStakeIxs({
+			amount,
+			lstMint: driftClient.getSpotMarketAccount(8).mint,
+			lstMarketIndex: 8,
+			jupiterClient,
+			driftClient,
+			userAccountPublicKey,
+			onlyDirectRoutes,
+		});
 	} else {
 		throw new Error(`Unsupported superstake market index: ${marketIndex}`);
 	}
@@ -153,16 +195,53 @@ export async function findBestJitoSolSuperStakeIxs({
 	lookupTables: AddressLookupTableAccount[];
 	method: 'jupiter' | 'marinade';
 	price: number;
+}> {
+	return await findBestLstSuperStakeIxs({
+		amount,
+		jupiterClient,
+		driftClient,
+		userAccountPublicKey,
+		onlyDirectRoutes,
+		lstMint: driftClient.getSpotMarketAccount(6).mint,
+		lstMarketIndex: 6,
+	});
+}
+
+/**
+ * Finds best Jupiter Swap instructions for a generic lstMint
+ *
+ * Without doing any extra steps like checking if you can get a better rate by staking directly with that LST platform
+ */
+export async function findBestLstSuperStakeIxs({
+	amount,
+	lstMint,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	onlyDirectRoutes,
+	lstMarketIndex,
+}: {
+	amount: BN;
+	lstMint: PublicKey;
+	lstMarketIndex: number;
+	jupiterClient: JupiterClient;
+	driftClient: DriftClient;
+	userAccountPublicKey?: PublicKey;
+	onlyDirectRoutes?: boolean;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price: number;
 }> {
 	const solMint = driftClient.getSpotMarketAccount(1).mint;
-	const JitoSolMint = driftClient.getSpotMarketAccount(6).mint;
 
 	let jupiterPrice;
 	let bestRoute;
 	try {
 		const jupiterRoutes = await jupiterClient.getRoutes({
 			inputMint: solMint,
-			outputMint: JitoSolMint,
+			outputMint: lstMint,
 			amount,
 			onlyDirectRoutes,
 		});
@@ -176,7 +255,7 @@ export async function findBestJitoSolSuperStakeIxs({
 
 	const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
 		inMarketIndex: 1,
-		outMarketIndex: 6,
+		outMarketIndex: lstMarketIndex,
 		route: bestRoute,
 		jupiterClient,
 		amount,
@@ -322,10 +401,27 @@ export async function calculateSolEarned({
 		}
 	};
 
+	const getBSolPrice = async (timestamps: number[]) => {
+		// Currently there's only one bSOL price, no timestamped data
+		// So just use the same price for every timestamp for now
+		const response = await fetchBSolMetrics();
+		if (response.status === 200) {
+			const data = (await response.json()) as BSOL_STATS_API_RESPONSE;
+			const bSolRatio = data?.stats?.conversion?.bsol_to_sol;
+			if (bSolRatio) {
+				timestamps.forEach((timestamp) => lstRatios.set(timestamp, bSolRatio));
+			}
+		}
+	};
+
+	// This block kind of assumes the record are all from the same market
+	// Otherwise the following code that checks the record.marketIndex would break
 	if (marketIndex === 2) {
 		await Promise.all(timestamps.map(getMsolPrice));
 	} else if (marketIndex === 6) {
 		lstRatios = await getJitoSolHistoricalPriceMap(timestamps);
+	} else if (marketIndex === 8) {
+		await getBSolPrice(timestamps);
 	}
 
 	let solEarned = ZERO;
@@ -336,23 +432,15 @@ export async function calculateSolEarned({
 			} else {
 				solEarned = solEarned.add(record.amount);
 			}
-		} else if (record.marketIndex === 2) {
-			const msolRatio = lstRatios.get(record.ts.toNumber());
-			const msolRatioBN = new BN(msolRatio * LAMPORTS_PER_SOL);
-
-			const solAmount = record.amount.mul(msolRatioBN).div(LAMPORTS_PRECISION);
-			if (isVariant(record.direction, 'deposit')) {
-				solEarned = solEarned.sub(solAmount);
-			} else {
-				solEarned = solEarned.add(solAmount);
-			}
-		} else if (record.marketIndex === 6) {
-			const jitoSolRatio = lstRatios.get(record.ts.toNumber());
-			const jitoSolRatioBN = new BN(jitoSolRatio * LAMPORTS_PER_SOL);
-
-			const solAmount = record.amount
-				.mul(jitoSolRatioBN)
-				.div(LAMPORTS_PRECISION);
+		} else if (
+			record.marketIndex === 2 ||
+			record.marketIndex === 6 ||
+			record.marketIndex === 8
+		) {
+			const lstRatio = lstRatios.get(record.ts.toNumber());
+			const lstRatioBN = new BN(lstRatio * LAMPORTS_PER_SOL);
+
+			const solAmount = record.amount.mul(lstRatioBN).div(LAMPORTS_PRECISION);
 			if (isVariant(record.direction, 'deposit')) {
 				solEarned = solEarned.sub(solAmount);
 			} else {

package/src/orderSubscriber/OrderSubscriber.ts

@@ -10,6 +10,7 @@ import { WebsocketSubscription } from './WebsocketSubscription';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { BN } from '../index';
+import { decodeUser } from '../decode/user';
 
 export class OrderSubscriber {
 	driftClient: DriftClient;
@@ -22,6 +23,7 @@ export class OrderSubscriber {
 	fetchPromiseResolver: () => void;
 
 	mostRecentSlot: number;
+	decodeFn: (name: string, data: Buffer) => UserAccount;
 
 	constructor(config: OrderSubscriberConfig) {
 		this.driftClient = config.driftClient;
@@ -39,6 +41,14 @@ export class OrderSubscriber {
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
 		}
+		if (config.fastDecode ?? true) {
+			this.decodeFn = (name, data) => decodeUser(data);
+		} else {
+			this.decodeFn =
+				this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.driftClient.program.account.user.coder.accounts
+				);
+		}
 		this.eventEmitter = new EventEmitter();
 	}
 
@@ -94,12 +104,16 @@ export class OrderSubscriber {
 					programAccount.account.data,
 					slot
 				);
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 
 			for (const key of this.usersAccounts.keys()) {
 				if (!programAccountSet.has(key)) {
 					this.usersAccounts.delete(key);
 				}
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 		} catch (e) {
 			console.error(e);
@@ -119,6 +133,13 @@ export class OrderSubscriber {
 			this.mostRecentSlot = slot;
 		}
 
+		this.eventEmitter.emit(
+			'updateReceived',
+			new PublicKey(key),
+			slot,
+			dataType
+		);
+
 		const slotAndUserAccount = this.usersAccounts.get(key);
 		if (!slotAndUserAccount || slotAndUserAccount.slot <= slot) {
 			let userAccount: UserAccount;
@@ -139,15 +160,19 @@ export class OrderSubscriber {
 					return;
 				}
 
-				userAccount =
-					this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
-						'User',
-						buffer
-					) as UserAccount;
+				userAccount = this.decodeFn('User', buffer) as UserAccount;
 			} else {
 				userAccount = data as UserAccount;
 			}
 
+			this.eventEmitter.emit(
+				'userUpdated',
+				userAccount,
+				new PublicKey(key),
+				slot,
+				dataType
+			);
+
 			const newOrders = userAccount.orders.filter(
 				(order) =>
 					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&
@@ -155,11 +180,12 @@ export class OrderSubscriber {
 			);
 			if (newOrders.length > 0) {
 				this.eventEmitter.emit(
-					'onUpdate',
+					'orderCreated',
 					userAccount,
 					newOrders,
 					new PublicKey(key),
-					slot
+					slot,
+					dataType
 				);
 			}
 			if (userAccount.hasOpenOrder) {

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -10,7 +10,7 @@ export class WebsocketSubscription {
 	private skipInitialLoad: boolean;
 	private resubTimeoutMs?: number;
 
-	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+	private subscriber?: WebSocketProgramAccountSubscriber<UserAccount>;
 
 	constructor({
 		orderSubscriber,
@@ -30,22 +30,22 @@ export class WebsocketSubscription {
 	}
 
 	public async subscribe(): Promise<void> {
-		if (!this.subscriber) {
-			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
-				'OrderSubscriber',
-				'User',
-				this.orderSubscriber.driftClient.program,
-				this.orderSubscriber.driftClient.program.account.user.coder.accounts.decode.bind(
-					this.orderSubscriber.driftClient.program.account.user.coder.accounts
-				),
-				{
-					filters: [getUserFilter(), getNonIdleUserFilter()],
-					commitment: this.commitment,
-				},
-				this.resubTimeoutMs
-			);
+		if (this.subscriber) {
+			return;
 		}
 
+		this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+			'OrderSubscriber',
+			'User',
+			this.orderSubscriber.driftClient.program,
+			this.orderSubscriber.decodeFn,
+			{
+				filters: [getUserFilter(), getNonIdleUserFilter()],
+				commitment: this.commitment,
+			},
+			this.resubTimeoutMs
+		);
+
 		await this.subscriber.subscribe(
 			(accountId: PublicKey, account: UserAccount, context: Context) => {
 				const userKey = accountId.toBase58();
@@ -65,6 +65,7 @@ export class WebsocketSubscription {
 
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscriber) return;
-		this.subscriber.unsubscribe();
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
 	}
 }

package/src/orderSubscriber/types.ts

@@ -16,13 +16,26 @@ export type OrderSubscriberConfig = {
 				resubTimeoutMs?: number;
 				commitment?: Commitment;
 		  };
+	fastDecode?: boolean;
 };
 
 export interface OrderSubscriberEvents {
-	onUpdate: (
+	orderCreated: (
 		account: UserAccount,
 		updatedOrders: Order[],
 		pubkey: PublicKey,
-		slot: number
+		slot: number,
+		dataType: 'raw' | 'decoded'
+	) => void;
+	userUpdated: (
+		account: UserAccount,
+		pubkey: PublicKey,
+		slot: number,
+		dataType: 'raw' | 'decoded'
+	) => void;
+	updateReceived: (
+		pubkey: PublicKey,
+		slot: number,
+		dataType: 'raw' | 'decoded'
 	) => void;
 }

package/src/types.ts

@@ -552,6 +552,7 @@ export type StateAccount = {
 	lpCooldownTime: BN;
 	initialPctToLiquidate: number;
 	liquidationDuration: number;
+	maxInitializeUserFee: number;
 };
 
 export type PerpMarketAccount = {
@@ -869,8 +870,8 @@ export type Order = {
 	marketIndex: number;
 	price: BN;
 	baseAssetAmount: BN;
-	baseAssetAmountFilled: BN;
 	quoteAssetAmount: BN;
+	baseAssetAmountFilled: BN;
 	quoteAssetAmountFilled: BN;
 	direction: PositionDirection;
 	reduceOnly: boolean;

package/src/user.ts

@@ -422,7 +422,8 @@ export class User {
 	public getPerpPositionWithLPSettle(
 		marketIndex: number,
 		originalPosition?: PerpPosition,
-		burnLpShares = false
+		burnLpShares = false,
+		includeRemainderInBaseAmount = false
 	): [PerpPosition, BN, BN] {
 		originalPosition =
 			originalPosition ??
@@ -600,7 +601,16 @@ export class User {
 			position.lastCumulativeFundingRate = ZERO;
 		}
 
-		return [position, remainderBaa, pnl];
+		const remainderBeforeRemoval = new BN(position.remainderBaseAssetAmount);
+
+		if (includeRemainderInBaseAmount) {
+			position.baseAssetAmount = position.baseAssetAmount.add(
+				remainderBeforeRemoval
+			);
+			position.remainderBaseAssetAmount = 0;
+		}
+
+		return [position, remainderBeforeRemoval, pnl];
 	}
 
 	/**
@@ -1559,16 +1569,19 @@ export class User {
 		);
 	}
 
+	getNetUsdValue(): BN {
+		const netSpotValue = this.getNetSpotMarketValue();
+		const unrealizedPnl = this.getUnrealizedPNL(true, undefined, undefined);
+		return netSpotValue.add(unrealizedPnl);
+	}
+
 	/**
 	 * Calculates the all time P&L of the user.
 	 *
 	 * Net withdraws + Net spot market value + Net unrealized P&L -
 	 */
 	getTotalAllTimePnl(): BN {
-		const netBankValue = this.getNetSpotMarketValue();
-		const unrealizedPnl = this.getUnrealizedPNL(true, undefined, undefined);
-
-		const netUsdValue = netBankValue.add(unrealizedPnl);
+		const netUsdValue = this.getNetUsdValue();
 		const totalDeposits = this.getUserAccount().totalDeposits;
 		const totalWithdraws = this.getUserAccount().totalWithdraws;
 

package/src/userMap/PollingSubscription.ts

@@ -0,0 +1,48 @@
+import { UserMap } from './userMap';
+
+export class PollingSubscription {
+	private userMap: UserMap;
+	private frequency: number;
+	private skipInitialLoad: boolean;
+
+	intervalId?: ReturnType<typeof setTimeout>;
+
+	constructor({
+		userMap,
+		frequency,
+		skipInitialLoad = false,
+	}: {
+		userMap: UserMap;
+		frequency: number;
+		skipInitialLoad?: boolean;
+		includeIdle?: boolean;
+	}) {
+		this.userMap = userMap;
+		this.frequency = frequency;
+		this.skipInitialLoad = skipInitialLoad;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		if (this.frequency > 0) {
+			this.intervalId = setInterval(
+				this.userMap.sync.bind(this.userMap),
+				this.frequency
+			);
+		}
+
+		if (!this.skipInitialLoad) {
+			await this.userMap.sync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/userMap/WebsocketSubscription.ts

@@ -0,0 +1,76 @@
+import { UserMap } from './userMap';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+
+export class WebsocketSubscription {
+	private userMap: UserMap;
+	private commitment: Commitment;
+	private skipInitialLoad: boolean;
+	private resubTimeoutMs?: number;
+	private includeIdle?: boolean;
+	private decodeFn: (name: string, data: Buffer) => UserAccount;
+
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+
+	constructor({
+		userMap,
+		commitment,
+		skipInitialLoad = false,
+		resubTimeoutMs,
+		includeIdle = false,
+		decodeFn,
+	}: {
+		userMap: UserMap;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubTimeoutMs?: number;
+		includeIdle?: boolean;
+		decodeFn: (name: string, data: Buffer) => UserAccount;
+	}) {
+		this.userMap = userMap;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.includeIdle = includeIdle || false;
+		this.decodeFn = decodeFn;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (!this.subscriber) {
+			const filters = [getUserFilter()];
+			if (!this.includeIdle) {
+				filters.push(getNonIdleUserFilter());
+			}
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'UserMap',
+				'User',
+				this.userMap.driftClient.program,
+				this.decodeFn,
+				{
+					filters,
+					commitment: this.commitment,
+				},
+				this.resubTimeoutMs
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, account: UserAccount, context: Context) => {
+				const userKey = accountId.toBase58();
+				this.userMap.updateUserAccount(userKey, account, context.slot);
+			}
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.userMap.sync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+	}
+}