@drift-labs/sdk 2.31.1-beta.9 → 2.32.0

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/utils.ts

@@ -34,6 +34,10 @@ export const divCeil = (a: BN, b: BN): BN => {
 	}
 };
 
+export const sigNum = (x: BN): BN => {
+	return x.isNeg() ? new BN(-1) : new BN(1);
+};
+
 /**
  * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
  * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates

package/src/orderParams.ts

@@ -1,8 +1,14 @@
-import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
+import {
+	DefaultOrderParams,
+	OptionalOrderParams,
+	OrderParams,
+	OrderTriggerCondition,
+	OrderType,
+} from './types';
 import { BN } from '@coral-xyz/anchor';
 
 export function getLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & { price: BN }
+	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
 ): OptionalOrderParams {
 	return Object.assign({}, params, {
 		orderType: OrderType.LIMIT,
@@ -10,7 +16,7 @@ export function getLimitOrderParams(
 }
 
 export function getTriggerMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+	params: Omit<OptionalOrderParams, 'orderType'> & {
 		triggerCondition: OrderTriggerCondition;
 		triggerPrice: BN;
 	}
@@ -21,7 +27,7 @@ export function getTriggerMarketOrderParams(
 }
 
 export function getTriggerLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+	params: Omit<OptionalOrderParams, 'orderType'> & {
 		triggerCondition: OrderTriggerCondition;
 		triggerPrice: BN;
 		price: BN;
@@ -33,9 +39,33 @@ export function getTriggerLimitOrderParams(
 }
 
 export function getMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>
+	params: Omit<OptionalOrderParams, 'orderType'>
 ): OptionalOrderParams {
 	return Object.assign({}, params, {
 		orderType: OrderType.MARKET,
 	});
 }
+
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */
+export function getOrderParams(
+	optionalOrderParams: OptionalOrderParams,
+	overridingParams: Record<string, any> = {}
+): OrderParams {
+	return Object.assign(
+		{},
+		DefaultOrderParams,
+		optionalOrderParams,
+		overridingParams
+	);
+}

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;