@drift-labs/sdk 2.40.0-beta.7 → 2.40.0-beta.9

package/src/math/superStake.ts

@@ -10,22 +10,25 @@ import { getMarinadeFinanceProgram, getMarinadeMSolPrice } from '../marinade';
 import { BN } from '@coral-xyz/anchor';
 import { User } from '../user';
 import { DepositRecord, isVariant } from '../types';
-import { LAMPORTS_PRECISION, ZERO } from '../constants/numericConstants';
+import { LAMPORTS_PRECISION, ZERO, NINE } from '../constants/numericConstants';
 import fetch from 'node-fetch';
+import { checkSameDate } from './utils';
 
 export async function findBestSuperStakeIxs({
+	marketIndex,
 	amount,
 	jupiterClient,
 	driftClient,
 	userAccountPublicKey,
-	marinadePrice,
+	price,
 	forceMarinade,
 	onlyDirectRoutes,
 }: {
+	marketIndex: number;
 	amount: BN;
 	jupiterClient: JupiterClient;
 	driftClient: DriftClient;
-	marinadePrice?: number;
+	price?: number;
 	userAccountPublicKey?: PublicKey;
 	forceMarinade?: boolean;
 	onlyDirectRoutes?: boolean;
@@ -35,9 +38,54 @@ export async function findBestSuperStakeIxs({
 	method: 'jupiter' | 'marinade';
 	price: number;
 }> {
-	if (!marinadePrice) {
+	if (marketIndex === 2) {
+		return findBestMSolSuperStakeIxs({
+			amount,
+			jupiterClient,
+			driftClient,
+			userAccountPublicKey,
+			price,
+			forceMarinade,
+			onlyDirectRoutes,
+		});
+	} else if (marketIndex === 6) {
+		return findBestJitoSolSuperStakeIxs({
+			amount,
+			jupiterClient,
+			driftClient,
+			userAccountPublicKey,
+			onlyDirectRoutes,
+		});
+	} else {
+		throw new Error(`Unsupported superstake market index: ${marketIndex}`);
+	}
+}
+
+export async function findBestMSolSuperStakeIxs({
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	price,
+	forceMarinade,
+	onlyDirectRoutes,
+}: {
+	amount: BN;
+	jupiterClient: JupiterClient;
+	driftClient: DriftClient;
+	price?: number;
+	userAccountPublicKey?: PublicKey;
+	forceMarinade?: boolean;
+	onlyDirectRoutes?: boolean;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price: number;
+}> {
+	if (!price) {
 		const marinadeProgram = getMarinadeFinanceProgram(driftClient.provider);
-		marinadePrice = await getMarinadeMSolPrice(marinadeProgram);
+		price = await getMarinadeMSolPrice(marinadeProgram);
 	}
 
 	const solMint = driftClient.getSpotMarketAccount(1).mint;
@@ -59,7 +107,7 @@ export async function findBestSuperStakeIxs({
 		console.error('Error getting jupiter price', e);
 	}
 
-	if (!jupiterPrice || marinadePrice <= jupiterPrice || forceMarinade) {
+	if (!jupiterPrice || price <= jupiterPrice || forceMarinade) {
 		const ixs = await driftClient.getStakeForMSOLIx({
 			amount,
 			userAccountPublicKey,
@@ -68,7 +116,7 @@ export async function findBestSuperStakeIxs({
 			method: 'marinade',
 			ixs,
 			lookupTables: [],
-			price: marinadePrice,
+			price: price,
 		};
 	} else {
 		const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
@@ -88,10 +136,170 @@ export async function findBestSuperStakeIxs({
 	}
 }
 
+export async function findBestJitoSolSuperStakeIxs({
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	onlyDirectRoutes,
+}: {
+	amount: BN;
+	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,
+			amount,
+			onlyDirectRoutes,
+		});
+
+		bestRoute = jupiterRoutes[0];
+		jupiterPrice = bestRoute.inAmount / bestRoute.outAmount;
+	} catch (e) {
+		console.error('Error getting jupiter price', e);
+		throw e;
+	}
+
+	const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
+		inMarketIndex: 1,
+		outMarketIndex: 6,
+		route: bestRoute,
+		jupiterClient,
+		amount,
+		userAccountPublicKey,
+	});
+	return {
+		method: 'jupiter',
+		ixs,
+		lookupTables,
+		price: jupiterPrice,
+	};
+}
+
+export type JITO_SOL_METRICS_ENDPOINT_RESPONSE = {
+	data: {
+		getStakePoolStats: {
+			tvl: {
+				// TVL in SOL, BN
+				data: number;
+				date: string;
+			}[];
+			supply: {
+				// jitoSOL supply
+				data: number;
+				date: string;
+			}[];
+			apy: {
+				data: number;
+				date: string;
+			}[];
+		};
+	};
+};
+
+const JITO_SOL_START_DATE = '2022-10-31T00:00:00Z';
+
+export async function fetchJitoSolMetrics() {
+	const res = await fetch('https://kobe.mainnet.jito.network/', {
+		body: JSON.stringify({
+			operationName: 'QueryRoot',
+			variables: {
+				request: {
+					bucketType: 'DAILY',
+					rangeFilter: {
+						start: JITO_SOL_START_DATE,
+						end: new Date().toISOString(),
+					},
+					sortBy: {
+						order: 'ASC',
+						field: 'BLOCK_TIME',
+					},
+				},
+			},
+			query: `
+						query QueryRoot($request: GetStakePoolStatsRequest!) {
+								getStakePoolStats(req: $request) {
+										tvl {
+												data
+												date
+										}
+										apy {
+												data
+												date
+										}
+										supply {
+												data
+												date
+										}
+								}
+						}
+				`,
+		}),
+		method: 'POST',
+	});
+
+	const data: JITO_SOL_METRICS_ENDPOINT_RESPONSE = await res.json();
+
+	return data;
+}
+
+const getJitoSolHistoricalPriceMap = async (timestamps: number[]) => {
+	try {
+		const data = await fetchJitoSolMetrics();
+		const jitoSolHistoricalPriceMap = new Map<number, number>();
+		const jitoSolHistoricalPriceInSol = [];
+
+		for (let i = 0; i < data.data.getStakePoolStats.supply.length; i++) {
+			const priceInSol =
+				data.data.getStakePoolStats.tvl[i].data /
+				new BN(10).pow(NINE) /
+				data.data.getStakePoolStats.supply[i].data;
+			jitoSolHistoricalPriceInSol.push({
+				price: priceInSol,
+				ts: data.data.getStakePoolStats.tvl[i].date,
+			});
+		}
+
+		for (const timestamp of timestamps) {
+			const date = new Date(timestamp * 1000);
+			const dateString = date.toISOString();
+
+			const price = jitoSolHistoricalPriceInSol.find((p) =>
+				checkSameDate(p.ts, dateString)
+			);
+
+			if (price) {
+				jitoSolHistoricalPriceMap.set(timestamp, price.price);
+			}
+		}
+
+		return jitoSolHistoricalPriceMap;
+	} catch (err) {
+		console.error(err);
+		return undefined;
+	}
+};
+
 export async function calculateSolEarned({
+	marketIndex,
 	user,
 	depositRecords,
 }: {
+	marketIndex: number;
 	user: User;
 	depositRecords: DepositRecord[];
 }): Promise<BN> {
@@ -101,20 +309,24 @@ export async function calculateSolEarned({
 		...depositRecords.map((r) => r.ts.toNumber()),
 	];
 
-	const msolRatios = new Map<number, number>();
+	let lstRatios = new Map<number, number>();
 
-	const getPrice = async (timestamp) => {
+	const getMsolPrice = async (timestamp) => {
 		const date = new Date(timestamp * 1000); // Convert Unix timestamp to milliseconds
 		const swaggerApiDateTime = date.toISOString(); // Format date as swagger API date-time
 		const url = `https://api.marinade.finance/msol/price_sol?time=${swaggerApiDateTime}`;
 		const response = await fetch(url);
 		if (response.status === 200) {
 			const data = await response.json();
-			msolRatios.set(timestamp, data);
+			lstRatios.set(timestamp, data);
 		}
 	};
 
-	await Promise.all(timestamps.map(getPrice));
+	if (marketIndex === 2) {
+		await Promise.all(timestamps.map(getMsolPrice));
+	} else if (marketIndex === 6) {
+		lstRatios = await getJitoSolHistoricalPriceMap(timestamps);
+	}
 
 	let solEarned = ZERO;
 	for (const record of depositRecords) {
@@ -125,7 +337,7 @@ export async function calculateSolEarned({
 				solEarned = solEarned.add(record.amount);
 			}
 		} else if (record.marketIndex === 2) {
-			const msolRatio = msolRatios.get(record.ts.toNumber());
+			const msolRatio = lstRatios.get(record.ts.toNumber());
 			const msolRatioBN = new BN(msolRatio * LAMPORTS_PER_SOL);
 
 			const solAmount = record.amount.mul(msolRatioBN).div(LAMPORTS_PRECISION);
@@ -134,34 +346,46 @@ export async function calculateSolEarned({
 			} 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);
+			if (isVariant(record.direction, 'deposit')) {
+				solEarned = solEarned.sub(solAmount);
+			} else {
+				solEarned = solEarned.add(solAmount);
+			}
 		}
 	}
 
-	const currentMSOLTokenAmount = await user.getTokenAmount(2);
-	const currentSOLTokenAmount = await user.getTokenAmount(1);
-
-	const currentMSOLRatio = msolRatios.get(now);
-	const currentMSOLRatioBN = new BN(currentMSOLRatio * LAMPORTS_PER_SOL);
+	const currentLstTokenAmount = await user.getTokenAmount(marketIndex);
+	const currentLstRatio = lstRatios.get(now);
+	const currentLstRatioBN = new BN(currentLstRatio * LAMPORTS_PER_SOL);
 
 	solEarned = solEarned.add(
-		currentMSOLTokenAmount.mul(currentMSOLRatioBN).div(LAMPORTS_PRECISION)
+		currentLstTokenAmount.mul(currentLstRatioBN).div(LAMPORTS_PRECISION)
 	);
+
+	const currentSOLTokenAmount = await user.getTokenAmount(1);
 	solEarned = solEarned.add(currentSOLTokenAmount);
 
 	return solEarned;
 }
 
-// calculate estimated liquidation price (in mSOL/SOL) based on target amounts
+// calculate estimated liquidation price (in LST/SOL) based on target amounts
 export function calculateEstimatedSuperStakeLiquidationPrice(
-	msolDepositAmount: number,
-	msolMaintenanceAssetWeight: number,
+	lstDepositAmount: number,
+	lstMaintenanceAssetWeight: number,
 	solBorrowAmount: number,
 	solMaintenanceLiabilityWeight: number,
-	msolPriceRatio: number
+	lstPriceRatio: number
 ): number {
 	const liquidationDivergence =
 		(solMaintenanceLiabilityWeight * solBorrowAmount) /
-		(msolMaintenanceAssetWeight * msolDepositAmount * msolPriceRatio);
-	const liquidationPrice = msolPriceRatio * liquidationDivergence;
+		(lstMaintenanceAssetWeight * lstDepositAmount * lstPriceRatio);
+	const liquidationPrice = lstPriceRatio * liquidationDivergence;
 	return liquidationPrice;
 }

package/src/math/utils.ts

@@ -83,3 +83,15 @@ export function timeRemainingUntilUpdate(
 
 	return timeRemainingUntilUpdate;
 }
+
+export const checkSameDate = (dateString1: string, dateString2: string) => {
+	const date1 = new Date(dateString1);
+	const date2 = new Date(dateString2);
+
+	const isSameDate =
+		date1.getDate() === date2.getDate() &&
+		date1.getMonth() === date2.getMonth() &&
+		date1.getFullYear() === date2.getFullYear();
+
+	return isSameDate;
+};

package/src/orderSubscriber/OrderSubscriber.ts

@@ -30,6 +30,7 @@ export class OrderSubscriber {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
 		}
 		this.eventEmitter = new EventEmitter();
@@ -86,7 +87,12 @@ export class OrderSubscriber {
 					programAccount.account.data[1]
 				);
 				programAccountSet.add(key);
-				this.tryUpdateUserAccount(key, buffer, slot);
+				const userAccount =
+					this.driftClient.program.account.user.coder.accounts.decode(
+						'User',
+						buffer
+					) as UserAccount;
+				this.tryUpdateUserAccount(key, userAccount, slot);
 			}
 
 			for (const key of this.usersAccounts.keys()) {
@@ -102,14 +108,13 @@ export class OrderSubscriber {
 		}
 	}
 
-	tryUpdateUserAccount(key: string, buffer: Buffer, slot: number): void {
+	tryUpdateUserAccount(
+		key: string,
+		userAccount: UserAccount,
+		slot: number
+	): void {
 		const slotAndUserAccount = this.usersAccounts.get(key);
 		if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
-			const userAccount =
-				this.driftClient.program.account.user.coder.accounts.decode(
-					'User',
-					buffer
-				) as UserAccount;
 			const newOrders = userAccount.orders.filter(
 				(order) =>
 					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -1,42 +1,57 @@
 import { OrderSubscriber } from './OrderSubscriber';
 import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Context, PublicKey } from '@solana/web3.js';
 
 export class WebsocketSubscription {
 	private orderSubscriber: OrderSubscriber;
 	private skipInitialLoad: boolean;
+	private resubTimeoutMs?: number;
 
-	private websocketId: number;
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
 	constructor({
 		orderSubscriber,
 		skipInitialLoad = false,
+		resubTimeoutMs,
 	}: {
 		orderSubscriber: OrderSubscriber;
 		skipInitialLoad?: boolean;
+		resubTimeoutMs?: number;
 	}) {
 		this.orderSubscriber = orderSubscriber;
 		this.skipInitialLoad = skipInitialLoad;
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<void> {
-		if (this.websocketId) {
-			return;
-		}
-
-		this.websocketId =
-			this.orderSubscriber.driftClient.connection.onProgramAccountChange(
-				this.orderSubscriber.driftClient.program.programId,
-				(keyAccountInfo, context) => {
-					const userKey = keyAccountInfo.accountId.toBase58();
-					this.orderSubscriber.tryUpdateUserAccount(
-						userKey,
-						keyAccountInfo.accountInfo.data,
-						context.slot
-					);
+		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.orderSubscriber.driftClient.opts.commitment,
 				},
-				this.orderSubscriber.driftClient.opts.commitment,
-				[getUserFilter(), getNonIdleUserFilter()]
+				this.resubTimeoutMs
 			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, account: UserAccount, context: Context) => {
+				const userKey = accountId.toBase58();
+				this.orderSubscriber.tryUpdateUserAccount(
+					userKey,
+					account,
+					context.slot
+				);
+			}
+		);
 
 		if (!this.skipInitialLoad) {
 			await this.orderSubscriber.fetch();
@@ -44,11 +59,6 @@ export class WebsocketSubscription {
 	}
 
 	public async unsubscribe(): Promise<void> {
-		if (this.websocketId) {
-			await this.orderSubscriber.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
-			this.websocketId = undefined;
-		}
+		this.subscriber.unsubscribe();
 	}
 }

package/src/orderSubscriber/types.ts

@@ -12,6 +12,7 @@ export type OrderSubscriberConfig = {
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;
+				resubTimeoutMs?: number;
 		  };
 };