@drift-labs/sdk 2.31.1-beta.2 → 2.31.1-beta.21

package/src/math/spotBalance.ts

@@ -236,18 +236,27 @@ export function calculateLiabilityWeight(
 	return liabilityWeight;
 }
 
-export function calculateUtilization(bank: SpotMarketAccount): BN {
-	const tokenDepositAmount = getTokenAmount(
+export function calculateUtilization(
+	bank: SpotMarketAccount,
+	delta = ZERO
+): BN {
+	let tokenDepositAmount = getTokenAmount(
 		bank.depositBalance,
 		bank,
 		SpotBalanceType.DEPOSIT
 	);
-	const tokenBorrowAmount = getTokenAmount(
+	let tokenBorrowAmount = getTokenAmount(
 		bank.borrowBalance,
 		bank,
 		SpotBalanceType.BORROW
 	);
 
+	if (delta.gt(ZERO)) {
+		tokenDepositAmount = tokenDepositAmount.add(delta);
+	} else if (delta.lt(ZERO)) {
+		tokenBorrowAmount = tokenBorrowAmount.add(delta.abs());
+	}
+
 	let utilization: BN;
 	if (tokenBorrowAmount.eq(ZERO) && tokenDepositAmount.eq(ZERO)) {
 		utilization = ZERO;
@@ -262,9 +271,78 @@ export function calculateUtilization(bank: SpotMarketAccount): BN {
 	return utilization;
 }
 
-export function calculateInterestRate(bank: SpotMarketAccount): BN {
-	const utilization = calculateUtilization(bank);
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+export function calculateSpotMarketBorrowCapacity(
+	spotMarketAccount: SpotMarketAccount,
+	targetBorrowRate: BN
+): BN {
+	const currentBorrowRate = calculateBorrowRate(spotMarketAccount);
 
+	if (currentBorrowRate.gte(targetBorrowRate)) {
+		return ZERO;
+	} else {
+		const tokenDepositAmount = getTokenAmount(
+			spotMarketAccount.depositBalance,
+			spotMarketAccount,
+			SpotBalanceType.DEPOSIT
+		);
+		const tokenBorrowAmount = getTokenAmount(
+			spotMarketAccount.borrowBalance,
+			spotMarketAccount,
+			SpotBalanceType.BORROW
+		);
+
+		let targetUtilization;
+
+		// target utilization past mid point
+		if (targetBorrowRate.gte(new BN(spotMarketAccount.optimalBorrowRate))) {
+			const borrowRateSlope = new BN(
+				spotMarketAccount.maxBorrowRate - spotMarketAccount.optimalBorrowRate
+			)
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(
+					SPOT_MARKET_UTILIZATION_PRECISION.sub(
+						new BN(spotMarketAccount.optimalUtilization)
+					)
+				);
+
+			const surplusTargetUtilization = targetBorrowRate
+				.sub(new BN(spotMarketAccount.optimalBorrowRate))
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(borrowRateSlope);
+
+			targetUtilization = surplusTargetUtilization.add(
+				new BN(spotMarketAccount.optimalUtilization)
+			);
+		} else {
+			const borrowRateSlope = new BN(spotMarketAccount.optimalBorrowRate)
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(new BN(spotMarketAccount.optimalUtilization));
+
+			targetUtilization = targetBorrowRate
+				.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+				.div(borrowRateSlope);
+		}
+
+		const targetBorrowAmount = tokenDepositAmount
+			.mul(targetUtilization)
+			.div(SPOT_MARKET_UTILIZATION_PRECISION);
+		const capacity = BN.max(ZERO, targetBorrowAmount.sub(tokenBorrowAmount));
+
+		return capacity;
+	}
+}
+
+export function calculateInterestRate(
+	bank: SpotMarketAccount,
+	delta = ZERO
+): BN {
+	const utilization = calculateUtilization(bank, delta);
 	let interestRate: BN;
 	if (utilization.gt(new BN(bank.optimalUtilization))) {
 		const surplusUtilization = utilization.sub(new BN(bank.optimalUtilization));

package/src/math/superStake.ts

@@ -0,0 +1,148 @@
+import {
+	AddressLookupTableAccount,
+	LAMPORTS_PER_SOL,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import { JupiterClient } from '../jupiter/jupiterClient';
+import { DriftClient } from '../driftClient';
+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 fetch from 'node-fetch';
+
+export async function findBestSuperStakeIxs({
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+}: {
+	amount: BN;
+	jupiterClient: JupiterClient;
+	driftClient: DriftClient;
+	userAccountPublicKey?: PublicKey;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price: number;
+}> {
+	const marinadeProgram = getMarinadeFinanceProgram(driftClient.provider);
+	const marinadePrice = await getMarinadeMSolPrice(marinadeProgram);
+
+	const solMint = driftClient.getSpotMarketAccount(1).mint;
+	const mSOLMint = driftClient.getSpotMarketAccount(2).mint;
+	const jupiterRoutes = await jupiterClient.getRoutes({
+		inputMint: solMint,
+		outputMint: mSOLMint,
+		amount,
+	});
+
+	const bestRoute = jupiterRoutes[0];
+	const jupiterPrice = bestRoute.inAmount / bestRoute.outAmount;
+
+	if (marinadePrice <= jupiterPrice) {
+		const ixs = await driftClient.getStakeForMSOLIx({ amount });
+		return {
+			method: 'marinade',
+			ixs,
+			lookupTables: [],
+			price: marinadePrice,
+		};
+	} else {
+		const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
+			inMarketIndex: 1,
+			outMarketIndex: 2,
+			route: bestRoute,
+			jupiterClient,
+			amount,
+			userAccountPublicKey,
+		});
+		return {
+			method: 'jupiter',
+			ixs,
+			lookupTables,
+			price: jupiterPrice,
+		};
+	}
+}
+
+export async function calculateSolEarned({
+	user,
+	depositRecords,
+}: {
+	user: User;
+	depositRecords: DepositRecord[];
+}): Promise<BN> {
+	const now = Date.now() / 1000;
+	const timestamps: number[] = [
+		now,
+		...depositRecords.map((r) => r.ts.toNumber()),
+	];
+
+	const msolRatios = new Map<number, number>();
+
+	const getPrice = 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);
+		}
+	};
+
+	await Promise.all(timestamps.map(getPrice));
+
+	let solEarned = ZERO;
+	for (const record of depositRecords) {
+		if (record.marketIndex === 1) {
+			if (isVariant(record.direction, 'deposit')) {
+				solEarned = solEarned.sub(record.amount);
+			} else {
+				solEarned = solEarned.add(record.amount);
+			}
+		} else if (record.marketIndex === 2) {
+			const msolRatio = msolRatios.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);
+			}
+		}
+	}
+
+	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);
+
+	solEarned = solEarned.add(
+		currentMSOLTokenAmount.mul(currentMSOLRatioBN).div(LAMPORTS_PRECISION)
+	);
+	solEarned = solEarned.add(currentSOLTokenAmount);
+
+	return solEarned;
+}
+
+// calculate estimated liquidation price (in mSOL/SOL) based on target amounts
+export function calculateEstimatedSuperStakeLiquidationPrice(
+	msolDepositAmount: number,
+	msolMaintenanceAssetWeight: number,
+	solBorrowAmount: number,
+	solMaintenanceLiabilityWeight: number,
+	msolPriceRatio: number
+): number {
+	const liquidationDivergence =
+		(solMaintenanceLiabilityWeight * solBorrowAmount) /
+		(msolMaintenanceAssetWeight * msolDepositAmount * msolPriceRatio);
+	const liquidationPrice = msolPriceRatio * liquidationDivergence;
+	return liquidationPrice;
+}

package/src/math/tiers.ts

@@ -0,0 +1,44 @@
+import { isVariant, PerpMarketAccount, SpotMarketAccount } from '../types';
+
+export function getPerpMarketTierNumber(perpMarket: PerpMarketAccount): number {
+	if (isVariant(perpMarket.contractTier, 'a')) {
+		return 0;
+	} else if (isVariant(perpMarket.contractTier, 'b')) {
+		return 1;
+	} else if (isVariant(perpMarket.contractTier, 'c')) {
+		return 2;
+	} else if (isVariant(perpMarket.contractTier, 'speculative')) {
+		return 3;
+	} else if (isVariant(perpMarket.contractTier, 'isolated')) {
+		return 4;
+	} else {
+		return 5;
+	}
+}
+
+export function getSpotMarketTierNumber(spotMarket: SpotMarketAccount): number {
+	if (isVariant(spotMarket.assetTier, 'collateral')) {
+		return 0;
+	} else if (isVariant(spotMarket.assetTier, 'protected')) {
+		return 1;
+	} else if (isVariant(spotMarket.assetTier, 'cross')) {
+		return 2;
+	} else if (isVariant(spotMarket.assetTier, 'isolated')) {
+		return 3;
+	} else if (isVariant(spotMarket.assetTier, 'unlisted')) {
+		return 4;
+	} else {
+		return 5;
+	}
+}
+
+export function perpTierIsAsSafeAs(
+	perpTier: number,
+	otherPerpTier: number,
+	otherSpotTier: number
+): boolean {
+	const asSafeAsPerp = perpTier <= otherPerpTier;
+	const asSafeAsSpot =
+		otherSpotTier === 4 || (otherSpotTier >= 2 && perpTier <= 2);
+	return asSafeAsSpot && asSafeAsPerp;
+}

package/src/tx/retryTxSender.ts

@@ -17,6 +17,7 @@ import {
 import { AnchorProvider } from '@coral-xyz/anchor';
 import assert from 'assert';
 import bs58 from 'bs58';
+import { IWallet } from '../types';
 
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
@@ -26,21 +27,34 @@ type ResolveReference = {
 };
 
 export class RetryTxSender implements TxSender {
-	provider: AnchorProvider;
+	connection: Connection;
+	wallet: IWallet;
+	opts: ConfirmOptions;
 	timeout: number;
 	retrySleep: number;
 	additionalConnections: Connection[];
 	timoutCount = 0;
 
-	public constructor(
-		provider: AnchorProvider,
-		timeout?: number,
-		retrySleep?: number,
-		additionalConnections = new Array<Connection>()
-	) {
-		this.provider = provider;
-		this.timeout = timeout ?? DEFAULT_TIMEOUT;
-		this.retrySleep = retrySleep ?? DEFAULT_RETRY;
+	public constructor({
+		connection,
+		wallet,
+		opts = AnchorProvider.defaultOptions(),
+		timeout = DEFAULT_TIMEOUT,
+		retrySleep = DEFAULT_RETRY,
+		additionalConnections = new Array<Connection>(),
+	}: {
+		connection: Connection;
+		wallet: IWallet;
+		opts?: ConfirmOptions;
+		timeout?: number;
+		retrySleep?: number;
+		additionalConnections?;
+	}) {
+		this.connection = connection;
+		this.wallet = wallet;
+		this.opts = opts;
+		this.timeout = timeout;
+		this.retrySleep = retrySleep;
 		this.additionalConnections = additionalConnections;
 	}
 
@@ -54,7 +68,7 @@ export class RetryTxSender implements TxSender {
 			additionalSigners = [];
 		}
 		if (opts === undefined) {
-			opts = this.provider.opts;
+			opts = this.opts;
 		}
 
 		const signedTx = preSigned
@@ -69,11 +83,9 @@ export class RetryTxSender implements TxSender {
 		additionalSigners: Array<Signer>,
 		opts: ConfirmOptions
 	): Promise<Transaction> {
-		tx.feePayer = this.provider.wallet.publicKey;
+		tx.feePayer = this.wallet.publicKey;
 		tx.recentBlockhash = (
-			await this.provider.connection.getRecentBlockhash(
-				opts.preflightCommitment
-			)
+			await this.connection.getRecentBlockhash(opts.preflightCommitment)
 		).blockhash;
 
 		additionalSigners
@@ -82,7 +94,7 @@ export class RetryTxSender implements TxSender {
 				tx.partialSign(kp);
 			});
 
-		const signedTx = await this.provider.wallet.signTransaction(tx);
+		const signedTx = await this.wallet.signTransaction(tx);
 
 		return signedTx;
 	}
@@ -97,15 +109,13 @@ export class RetryTxSender implements TxSender {
 			additionalSigners = [];
 		}
 		if (opts === undefined) {
-			opts = this.provider.opts;
+			opts = this.opts;
 		}
 
 		const message = new TransactionMessage({
-			payerKey: this.provider.wallet.publicKey,
+			payerKey: this.wallet.publicKey,
 			recentBlockhash: (
-				await this.provider.connection.getRecentBlockhash(
-					opts.preflightCommitment
-				)
+				await this.connection.getRecentBlockhash(opts.preflightCommitment)
 			).blockhash,
 			instructions: ixs,
 		}).compileToV0Message(lookupTableAccounts);
@@ -125,9 +135,9 @@ export class RetryTxSender implements TxSender {
 		if (preSigned) {
 			signedTx = tx;
 			// @ts-ignore
-		} else if (this.provider.wallet.payer) {
+		} else if (this.wallet.payer) {
 			// @ts-ignore
-			tx.sign((additionalSigners ?? []).concat(this.provider.wallet.payer));
+			tx.sign((additionalSigners ?? []).concat(this.wallet.payer));
 			signedTx = tx;
 		} else {
 			additionalSigners
@@ -136,11 +146,11 @@ export class RetryTxSender implements TxSender {
 					tx.sign([kp]);
 				});
 			// @ts-ignore
-			signedTx = await this.provider.wallet.signTransaction(tx);
+			signedTx = await this.wallet.signTransaction(tx);
 		}
 
 		if (opts === undefined) {
-			opts = this.provider.opts;
+			opts = this.opts;
 		}
 
 		return this.sendRawTransaction(signedTx.serialize(), opts);
@@ -154,10 +164,7 @@ export class RetryTxSender implements TxSender {
 
 		let txid: TransactionSignature;
 		try {
-			txid = await this.provider.connection.sendRawTransaction(
-				rawTransaction,
-				opts
-			);
+			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
 			this.sendToAdditionalConnections(rawTransaction, opts);
 		} catch (e) {
 			console.error(e);
@@ -179,7 +186,7 @@ export class RetryTxSender implements TxSender {
 			while (!done && this.getTimestamp() - startTime < this.timeout) {
 				await this.sleep(resolveReference);
 				if (!done) {
-					this.provider.connection
+					this.connection
 						.sendRawTransaction(rawTransaction, opts)
 						.catch((e) => {
 							console.error(e);
@@ -218,13 +225,10 @@ export class RetryTxSender implements TxSender {
 		assert(decodedSignature.length === 64, 'signature has invalid length');
 
 		const start = Date.now();
-		const subscriptionCommitment = commitment || this.provider.opts.commitment;
+		const subscriptionCommitment = commitment || this.opts.commitment;
 
 		const subscriptionIds = new Array<number>();
-		const connections = [
-			this.provider.connection,
-			...this.additionalConnections,
-		];
+		const connections = [this.connection, ...this.additionalConnections];
 		let response: RpcResponseAndContext<SignatureResult> | null = null;
 		const promises = connections.map((connection, i) => {
 			let subscriptionId;

package/src/tx/types.ts

@@ -1,4 +1,3 @@
-import { Provider } from '@coral-xyz/anchor';
 import {
 	AddressLookupTableAccount,
 	ConfirmOptions,
@@ -8,6 +7,7 @@ import {
 	TransactionSignature,
 	VersionedTransaction,
 } from '@solana/web3.js';
+import { IWallet } from '../types';
 
 export type TxSigAndSlot = {
 	txSig: TransactionSignature;
@@ -15,7 +15,7 @@ export type TxSigAndSlot = {
 };
 
 export interface TxSender {
-	provider: Provider;
+	wallet: IWallet;
 
 	send(
 		tx: Transaction,

package/src/user.ts

@@ -72,6 +72,7 @@ import {
 } from './math/spotPosition';
 
 import { calculateLiveOracleTwap } from './math/oracles';
+import { getPerpMarketTierNumber, getSpotMarketTierNumber } from './math/tiers';
 
 export class User {
 	driftClient: DriftClient;
@@ -97,6 +98,8 @@ export class User {
 				config.userAccountPublicKey,
 				config.accountSubscription.accountLoader
 			);
+		} else if (config.accountSubscription?.type === 'custom') {
+			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
 		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
@@ -301,7 +304,10 @@ export class User {
 		marketIndex: number,
 		originalPosition?: PerpPosition
 	): [PerpPosition, BN, BN] {
-		originalPosition = originalPosition ?? this.getPerpPosition(marketIndex);
+		originalPosition =
+			originalPosition ??
+			this.getPerpPosition(marketIndex) ??
+			this.getEmptyPosition(marketIndex);
 
 		if (originalPosition.lpShares.eq(ZERO)) {
 			return [originalPosition, ZERO, ZERO];
@@ -368,7 +374,7 @@ export class User {
 		let pnl;
 		if (updateType == 'open' || updateType == 'increase') {
 			newQuoteEntry = position.quoteEntryAmount.add(deltaQaa);
-			pnl = 0;
+			pnl = ZERO;
 		} else if (updateType == 'reduce' || updateType == 'close') {
 			newQuoteEntry = position.quoteEntryAmount.sub(
 				position.quoteEntryAmount
@@ -490,6 +496,12 @@ export class User {
 		);
 	}
 
+	public getActiveSpotPositions(): SpotPosition[] {
+		return this.getUserAccount().spotPositions.filter(
+			(pos) => !isSpotPositionAvailable(pos)
+		);
+	}
+
 	/**
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION
@@ -1127,7 +1139,8 @@ export class User {
 		includeOpenOrders = false
 	): BN {
 		const userPosition =
-			this.getPerpPosition(marketIndex) || this.getEmptyPosition(marketIndex);
+			this.getPerpPositionWithLPSettle(marketIndex)[0] ||
+			this.getEmptyPosition(marketIndex);
 		const market = this.driftClient.getPerpMarketAccount(
 			userPosition.marketIndex
 		);
@@ -1435,24 +1448,29 @@ export class User {
 		return netAssetValue.mul(TEN_THOUSAND).div(totalLiabilityValue);
 	}
 
-	public canBeLiquidated(): boolean {
+	public canBeLiquidated(): {
+		canBeLiquidated: boolean;
+		marginRequirement: BN;
+		totalCollateral: BN;
+	} {
 		const totalCollateral = this.getTotalCollateral('Maintenance');
 
 		// if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
 		let liquidationBuffer = undefined;
-		const isBeingLiquidated = isVariant(
-			this.getUserAccount().status,
-			'beingLiquidated'
-		);
-
-		if (isBeingLiquidated) {
+		if (this.isBeingLiquidated()) {
 			liquidationBuffer = new BN(
 				this.driftClient.getStateAccount().liquidationMarginBufferRatio
 			);
 		}
-		const maintenanceRequirement =
+		const marginRequirement =
 			this.getMaintenanceMarginRequirement(liquidationBuffer);
-		return totalCollateral.lt(maintenanceRequirement);
+		const canBeLiquidated = totalCollateral.lt(marginRequirement);
+
+		return {
+			canBeLiquidated,
+			marginRequirement,
+			totalCollateral,
+		};
 	}
 
 	public isBeingLiquidated(): boolean {
@@ -2304,6 +2322,38 @@ export class User {
 		return true;
 	}
 
+	public getSafestTiers(): { perpTier: number; spotTier: number } {
+		let safestPerpTier = 4;
+		let safestSpotTier = 4;
+
+		for (const perpPosition of this.getActivePerpPositions()) {
+			safestPerpTier = Math.min(
+				safestPerpTier,
+				getPerpMarketTierNumber(
+					this.driftClient.getPerpMarketAccount(perpPosition.marketIndex)
+				)
+			);
+		}
+
+		for (const spotPosition of this.getActiveSpotPositions()) {
+			if (isVariant(spotPosition.balanceType, 'deposit')) {
+				continue;
+			}
+
+			safestSpotTier = Math.min(
+				safestSpotTier,
+				getSpotMarketTierNumber(
+					this.driftClient.getSpotMarketAccount(spotPosition.marketIndex)
+				)
+			);
+		}
+
+		return {
+			perpTier: safestPerpTier,
+			spotTier: safestSpotTier,
+		};
+	}
+
 	/**
 	 * Get the total position value, excluding any position coming from the given target market
 	 * @param marketToIgnore
@@ -2345,6 +2395,7 @@ export class User {
 
 		return oracleData;
 	}
+
 	private getOracleDataForSpotMarket(marketIndex: number): OraclePriceData {
 		const oracleKey = this.driftClient.getSpotMarketAccount(marketIndex).oracle;
 

package/src/userConfig.ts

@@ -1,6 +1,7 @@
 import { DriftClient } from './driftClient';
 import { PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { UserAccountSubscriber } from './accounts/types';
 
 export type UserConfig = {
 	accountSubscription?: UserSubscriptionConfig;
@@ -15,4 +16,8 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'polling';
 			accountLoader: BulkAccountLoader;
+	  }
+	| {
+			type: 'custom';
+			userAccountSubscriber: UserAccountSubscriber;
 	  };

package/src/userStats.ts

@@ -25,6 +25,10 @@ export class UserStats {
 				config.userStatsAccountPublicKey,
 				config.accountSubscription.accountLoader
 			);
+		} else if (config.accountSubscription?.type === 'custom') {
+			throw new Error(
+				'Custom account subscription not yet implemented for user stats'
+			);
 		} else {
 			this.accountSubscriber = new WebSocketUserStatsAccountSubscriber(
 				config.driftClient.program,

package/src/userStatsConfig.ts

@@ -15,4 +15,7 @@ export type UserStatsSubscriptionConfig =
 	| {
 			type: 'polling';
 			accountLoader: BulkAccountLoader;
+	  }
+	| {
+			type: 'custom';
 	  };