@drift-labs/sdk 2.49.0-beta.1 → 2.49.0-beta.11

package/src/events/eventSubscriber.ts

@@ -47,7 +47,7 @@ export class EventSubscriber {
 				new EventList(
 					eventType,
 					this.options.maxEventsPerType,
-					getSortFn(this.options.orderBy, this.options.orderDir, eventType),
+					getSortFn(this.options.orderBy, this.options.orderDir),
 					this.options.orderDir
 				)
 			);
@@ -159,6 +159,7 @@ export class EventSubscriber {
 
 		if (!this.lastSeenSlot || slot > this.lastSeenSlot) {
 			this.lastSeenTxSig = txSig;
+			this.lastSeenSlot = slot;
 		}
 
 		if (

package/src/events/sort.ts

@@ -4,10 +4,7 @@ import {
 	EventSubscriptionOrderDirection,
 	EventType,
 	SortFn,
-	Event,
 } from './types';
-import { OrderActionRecord } from '../types';
-import { ZERO } from '../index';
 
 function clientSortAscFn(): 'less than' {
 	return 'less than';
@@ -17,45 +14,26 @@ function clientSortDescFn(): 'greater than' {
 	return 'greater than';
 }
 
-function defaultBlockchainSortFn(
+function blockchainSortFn(
 	currentEvent: EventMap[EventType],
 	newEvent: EventMap[EventType]
 ): 'less than' | 'greater than' {
-	return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
-}
-
-function orderActionRecordSortFn(
-	currentEvent: Event<OrderActionRecord>,
-	newEvent: Event<OrderActionRecord>
-): 'less than' | 'greater than' {
-	const currentEventMarketIndex = currentEvent.marketIndex;
-	const newEventMarketIndex = newEvent.marketIndex;
-	if (currentEventMarketIndex !== newEventMarketIndex) {
-		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
-	}
-
-	if (currentEvent.fillRecordId?.gt(ZERO) && newEvent.fillRecordId?.gt(ZERO)) {
-		return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+	if (currentEvent.slot == newEvent.slot) {
+		return currentEvent.txSigIndex < newEvent.txSigIndex
 			? 'less than'
 			: 'greater than';
-	} else {
-		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
 	}
+
+	return currentEvent.slot < newEvent.slot ? 'less than' : 'greater than';
 }
 
 export function getSortFn(
 	orderBy: EventSubscriptionOrderBy,
-	orderDir: EventSubscriptionOrderDirection,
-	eventType: EventType
+	orderDir: EventSubscriptionOrderDirection
 ): SortFn {
 	if (orderBy === 'client') {
 		return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
 	}
 
-	switch (eventType) {
-		case 'OrderActionRecord':
-			return orderActionRecordSortFn;
-		default:
-			return defaultBlockchainSortFn;
-	}
+	return blockchainSortFn;
 }

package/src/examples/loadDlob.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider } from '@coral-xyz/anchor';
-import { DLOB, UserMap, Wallet } from '..';
+import { UserMap, Wallet } from '..';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
 	DriftClient,
@@ -55,17 +55,22 @@ const main = async () => {
 	await driftClient.subscribe();
 
 	console.log('Loading user map...');
-	const userMap = new UserMap(driftClient, {
-		type: 'polling',
-		accountLoader: bulkAccountLoader,
+	const userMap = new UserMap({
+		driftClient,
+		subscriptionConfig: {
+			type: 'websocket',
+			commitment: 'processed',
+		},
+		skipInitialLoad: false,
+		includeIdle: false,
 	});
 
 	// fetches all users and subscribes for updates
 	await userMap.subscribe();
 
 	console.log('Loading dlob from user map...');
-	const dlob = new DLOB();
-	await dlob.initFromUserMap(userMap, bulkAccountLoader.mostRecentSlot);
+	const slot = await driftClient.connection.getSlot();
+	const dlob = await userMap.getDLOB(slot);
 
 	console.log('number of orders', dlob.getDLOBOrders().length);
 

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './types';
 export * from './constants/perpMarkets';
 export * from './accounts/fetch';
 export * from './accounts/webSocketDriftClientAccountSubscriber';
+export * from './accounts/webSocketInsuranceFundStakeAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
 export * from './accounts/bulkUserStatsSubscription';
@@ -18,7 +19,8 @@ export * from './accounts/pollingOracleAccountSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/pollingUserAccountSubscriber';
 export * from './accounts/pollingUserStatsAccountSubscriber';
-export * from './accounts/mockUserAccountSubscriber';
+export * from './accounts/pollingInsuranceFundStakeAccountSubscriber';
+export * from './accounts/basicUserAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './adminClient';

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

@@ -94,12 +94,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);

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,24 @@ 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.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+				this.orderSubscriber.driftClient.program.account.user.coder.accounts
+			),
+			{
+				filters: [getUserFilter(), getNonIdleUserFilter()],
+				commitment: this.commitment,
+			},
+			this.resubTimeoutMs
+		);
+
 		await this.subscriber.subscribe(
 			(accountId: PublicKey, account: UserAccount, context: Context) => {
 				const userKey = accountId.toBase58();
@@ -65,6 +67,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/types.ts

@@ -1000,8 +1000,6 @@ export interface IVersionedWallet {
 
 export type FeeStructure = {
 	feeTiers: FeeTier[];
-	makerRebateNumerator: BN;
-	makerRebateDenominator: BN;
 	fillerRewardStructure: OrderFillerRewardStructure;
 	flatFillerFee: BN;
 	referrerRewardEpochUpperBound: BN;

package/src/userMap/PollingSubscription.ts

@@ -0,0 +1,46 @@
+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;
+		}
+
+		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,74 @@
+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 subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+
+	constructor({
+		userMap,
+		commitment,
+		skipInitialLoad = false,
+		resubTimeoutMs,
+		includeIdle = false,
+	}: {
+		userMap: UserMap;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubTimeoutMs?: number;
+		includeIdle?: boolean;
+	}) {
+		this.userMap = userMap;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.includeIdle = includeIdle || false;
+	}
+
+	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.userMap.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.userMap.driftClient.program.account.user.coder.accounts
+				),
+				{
+					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;
+	}
+}