@drift-labs/sdk 2.41.0-beta.0 → 2.41.0-beta.2

package/src/jupiter/jupiterClient.ts

@@ -275,16 +275,20 @@ export class JupiterClient {
 		inputMint,
 		outputMint,
 		amount,
+		maxAccounts = 50, // 50 is an estimated amount with buffer
 		slippageBps = 50,
 		swapMode = 'ExactIn',
 		onlyDirectRoutes = false,
+		excludeDexes = [],
 	}: {
 		inputMint: PublicKey;
 		outputMint: PublicKey;
 		amount: BN;
+		maxAccounts?: number;
 		slippageBps?: number;
 		swapMode?: SwapMode;
 		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
 	}): Promise<QuoteResponse> {
 		const params = new URLSearchParams({
 			inputMint: inputMint.toString(),
@@ -293,6 +297,8 @@ export class JupiterClient {
 			slippageBps: slippageBps.toString(),
 			swapMode,
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
+			maxAccounts: maxAccounts.toString(),
+			excludeDexes: excludeDexes.join(','),
 		}).toString();
 		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
 		return quote;

package/src/math/amm.ts

@@ -471,12 +471,19 @@ export function calculateVolSpreadBN(
 		clampMax
 	);
 
+	// only consider confidence interval at full value when above 25 bps
+	let confComponent = lastOracleConfPct;
+
+	if (lastOracleConfPct.lte(PRICE_PRECISION.div(new BN(400)))) {
+		confComponent = lastOracleConfPct.div(new BN(10));
+	}
+
 	const longVolSpread = BN.max(
-		lastOracleConfPct,
+		confComponent,
 		volSpread.mul(longVolSpreadFactor).div(PERCENTAGE_PRECISION)
 	);
 	const shortVolSpread = BN.max(
-		lastOracleConfPct,
+		confComponent,
 		volSpread.mul(shortVolSpreadFactor).div(PERCENTAGE_PRECISION)
 	);
 

package/src/math/auction.ts

@@ -1,5 +1,5 @@
-import { isOneOfVariant, isVariant, Order } from '../types';
-import { BN, ZERO } from '../.';
+import { isOneOfVariant, isVariant, Order, PositionDirection } from '../types';
+import { BN, ONE, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
 	if (order.auctionDuration === 0) {
@@ -104,3 +104,37 @@ export function getAuctionPriceForOracleOffsetAuction(
 
 	return oraclePrice.add(priceOffset);
 }
+
+export function deriveOracleAuctionParams({
+	direction,
+	oraclePrice,
+	auctionStartPrice,
+	auctionEndPrice,
+	limitPrice,
+}: {
+	direction: PositionDirection;
+	oraclePrice: BN;
+	auctionStartPrice: BN;
+	auctionEndPrice: BN;
+	limitPrice: BN;
+}): { auctionStartPrice: BN; auctionEndPrice: BN; oraclePriceOffset: number } {
+	let oraclePriceOffset = limitPrice.sub(oraclePrice);
+	if (oraclePriceOffset.eq(ZERO)) {
+		oraclePriceOffset = isVariant(direction, 'long')
+			? auctionEndPrice.sub(oraclePrice).add(ONE)
+			: auctionEndPrice.sub(oraclePrice).sub(ONE);
+	}
+
+	let oraclePriceOffsetNum;
+	try {
+		oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+	} catch (e) {
+		oraclePriceOffsetNum = 0;
+	}
+
+	return {
+		auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+		auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+		oraclePriceOffset: oraclePriceOffsetNum,
+	};
+}

package/src/math/market.ts

@@ -279,27 +279,22 @@ export function calculateAvailablePerpLiquidity(
 
 	asks = asks.abs();
 
-	const bidPrice = calculateBidPrice(market, oraclePriceData);
-	const askPrice = calculateAskPrice(market, oraclePriceData);
-
-	for (const bid of dlob.getMakerLimitBids(
+	for (const bid of dlob.getRestingLimitBids(
 		market.marketIndex,
 		slot,
 		MarketType.PERP,
-		oraclePriceData,
-		askPrice
+		oraclePriceData
 	)) {
 		bids = bids.add(
 			bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled)
 		);
 	}
 
-	for (const ask of dlob.getMakerLimitAsks(
+	for (const ask of dlob.getRestingLimitAsks(
 		market.marketIndex,
 		slot,
 		MarketType.PERP,
-		oraclePriceData,
-		bidPrice
+		oraclePriceData
 	)) {
 		asks = asks.add(
 			ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled)

package/src/math/superStake.ts

@@ -12,20 +12,23 @@ import { User } from '../user';
 import { DepositRecord, isVariant } from '../types';
 import { LAMPORTS_PRECISION, ZERO } 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 /
+				10 ** 9 /
+				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/trade.ts

@@ -411,16 +411,8 @@ export function calculateEstimatedPerpEntryPrice(
 
 	const takerIsLong = isVariant(direction, 'long');
 	const limitOrders = dlob[
-		takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'
-	](
-		market.marketIndex,
-		slot,
-		MarketType.PERP,
-		oraclePriceData,
-		takerIsLong
-			? calculateBidPrice(market, oraclePriceData)
-			: calculateAskPrice(market, oraclePriceData)
-	);
+		takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'
+	](market.marketIndex, slot, MarketType.PERP, oraclePriceData);
 
 	const swapDirection = getSwapDirection(assetType, direction);
 
@@ -726,7 +718,7 @@ export function calculateEstimatedSpotEntryPrice(
 
 	const takerIsLong = isVariant(direction, 'long');
 	const dlobLimitOrders = dlob[
-		takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'
+		takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'
 	](market.marketIndex, slot, MarketType.SPOT, oraclePriceData);
 	const serumLimitOrders = takerIsLong
 		? serumAsks.getL2(100)

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,7 @@ export class WebsocketSubscription {
 	}
 
 	public async unsubscribe(): Promise<void> {
-		if (this.websocketId) {
-			await this.orderSubscriber.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
-			this.websocketId = undefined;
-		}
+		if (!this.subscriber) return;
+		this.subscriber.unsubscribe();
 	}
 }

package/src/orderSubscriber/types.ts

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