@velocity-exchange/sdk 0.0.1

package/src/math/superStake.ts

@@ -0,0 +1,528 @@
+import {
+	AddressLookupTableAccount,
+	LAMPORTS_PER_SOL,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import { JupiterClient, QuoteResponse } from '../jupiter/jupiterClient';
+import { VelocityClient } from '../velocityClient';
+import { getMarinadeFinanceProgram, getMarinadeMSolPrice } from '../marinade';
+import { BN } from '../isomorphic/anchor';
+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 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 fetchBSolVelocityEmissions() {
+	return await fetch('https://stake.solblaze.org/api/v1/drift_emissions');
+}
+
+/** @deprecated Use `fetchBSolVelocityEmissions` instead. `fetchBSolDriftEmissions` will be removed in a future major. */
+export const fetchBSolDriftEmissions = fetchBSolVelocityEmissions;
+
+export async function findBestSuperStakeIxs({
+	marketIndex,
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	price,
+	forceMarinade,
+	onlyDirectRoutes,
+	jupiterQuote,
+}: {
+	marketIndex: number;
+	amount: BN;
+	jupiterClient: JupiterClient;
+	driftClient: VelocityClient;
+	price?: number;
+	userAccountPublicKey?: PublicKey;
+	forceMarinade?: boolean;
+	onlyDirectRoutes?: boolean;
+	jupiterQuote?: QuoteResponse;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price?: number;
+}> {
+	if (marketIndex === 2) {
+		return findBestMSolSuperStakeIxs({
+			amount,
+			jupiterClient,
+			driftClient,
+			userAccountPublicKey,
+			price,
+			forceMarinade,
+			onlyDirectRoutes,
+			jupiterQuote,
+		});
+	} else if (marketIndex === 6) {
+		return findBestJitoSolSuperStakeIxs({
+			amount,
+			jupiterClient,
+			driftClient,
+			userAccountPublicKey,
+			onlyDirectRoutes,
+			jupiterQuote,
+		});
+	} else if (marketIndex === 8) {
+		return findBestLstSuperStakeIxs({
+			amount,
+			lstMint: driftClient.getSpotMarketAccount(8).mint,
+			lstMarketIndex: 8,
+			jupiterClient,
+			driftClient,
+			userAccountPublicKey,
+			onlyDirectRoutes,
+			jupiterQuote,
+		});
+	} else {
+		throw new Error(`Unsupported superstake market index: ${marketIndex}`);
+	}
+}
+
+export async function findBestMSolSuperStakeIxs({
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	price,
+	forceMarinade,
+	onlyDirectRoutes,
+	jupiterQuote,
+}: {
+	amount: BN;
+	jupiterClient: JupiterClient;
+	driftClient: VelocityClient;
+	price?: number;
+	userAccountPublicKey?: PublicKey;
+	forceMarinade?: boolean;
+	onlyDirectRoutes?: boolean;
+	jupiterQuote?: QuoteResponse;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price: number;
+}> {
+	if (!price) {
+		const marinadeProgram = getMarinadeFinanceProgram(driftClient.provider);
+		price = await getMarinadeMSolPrice(marinadeProgram);
+	}
+
+	const solSpotMarketAccount = driftClient.getSpotMarketAccount(1);
+	const mSolSpotMarketAccount = driftClient.getSpotMarketAccount(2);
+
+	let jupiterPrice: number;
+	let quote = jupiterQuote;
+	if (!jupiterQuote) {
+		try {
+			const fetchedQuote = await jupiterClient.getQuote({
+				inputMint: solSpotMarketAccount.mint,
+				outputMint: mSolSpotMarketAccount.mint,
+				amount,
+				slippageBps: 1000,
+				onlyDirectRoutes,
+			});
+
+			jupiterPrice = +quote.outAmount / +quote.inAmount;
+
+			quote = fetchedQuote;
+		} catch (e) {
+			console.error('Error getting jupiter price', e);
+		}
+	}
+
+	if (!jupiterPrice || price <= jupiterPrice || forceMarinade) {
+		const ixs = await driftClient.getStakeForMSOLIx({
+			amount,
+			userAccountPublicKey,
+		});
+		return {
+			method: 'marinade',
+			ixs,
+			lookupTables: [],
+			price: price,
+		};
+	} else {
+		const { ixs, lookupTables } = await driftClient.getJupiterSwapIxV6({
+			inMarketIndex: 1,
+			outMarketIndex: 2,
+			jupiterClient,
+			amount,
+			userAccountPublicKey,
+			onlyDirectRoutes,
+			quote,
+		});
+		return {
+			method: 'jupiter',
+			ixs,
+			lookupTables,
+			price: jupiterPrice,
+		};
+	}
+}
+
+export async function findBestJitoSolSuperStakeIxs({
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	onlyDirectRoutes,
+	jupiterQuote,
+}: {
+	amount: BN;
+	jupiterClient: JupiterClient;
+	driftClient: VelocityClient;
+	userAccountPublicKey?: PublicKey;
+	onlyDirectRoutes?: boolean;
+	jupiterQuote?: QuoteResponse;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price?: number;
+}> {
+	return await findBestLstSuperStakeIxs({
+		amount,
+		jupiterClient,
+		driftClient,
+		userAccountPublicKey,
+		onlyDirectRoutes,
+		lstMint: driftClient.getSpotMarketAccount(6).mint,
+		lstMarketIndex: 6,
+		jupiterQuote,
+	});
+}
+
+/**
+ * Finds best 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,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+	onlyDirectRoutes,
+	lstMarketIndex,
+	jupiterQuote,
+}: {
+	amount: BN;
+	lstMint: PublicKey;
+	lstMarketIndex: number;
+	jupiterClient: JupiterClient;
+	driftClient: VelocityClient;
+	userAccountPublicKey?: PublicKey;
+	onlyDirectRoutes?: boolean;
+	jupiterQuote?: QuoteResponse;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+}> {
+	const { ixs, lookupTables } = await driftClient.getJupiterSwapIxV6({
+		inMarketIndex: 1,
+		outMarketIndex: lstMarketIndex,
+		jupiterClient,
+		amount,
+		userAccountPublicKey,
+		onlyDirectRoutes,
+		quote: jupiterQuote,
+	});
+	return {
+		method: 'jupiter',
+		ixs,
+		lookupTables,
+		// price: jupiterPrice,
+	};
+}
+
+export type JITO_SOL_METRICS_ENDPOINT_RESPONSE = {
+	tvl: {
+		// TVL in SOL, BN
+		data: number;
+		date: string;
+	}[];
+	supply: {
+		// jitoSOL supply
+		data: number;
+		date: string;
+	}[];
+	apy: {
+		data: number;
+		date: string;
+	}[];
+};
+
+/**
+ * Removes hours, minutes, seconds from a date, and returns the ISO string value (with milliseconds trimmed from the output (required by Jito API))
+ * @param inDate
+ * @returns
+ */
+const getNormalizedDateString = (inDate: Date) => {
+	const date = new Date(inDate.getTime());
+	date.setUTCHours(0, 0, 0, 0);
+	return date.toISOString().slice(0, 19) + 'Z';
+};
+
+const get30DAgo = () => {
+	const date = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+	return date;
+};
+
+export async function fetchJitoSolMetrics() {
+	const res = await fetch(
+		'https://kobe.mainnet.jito.network/api/v1/stake_pool_stats',
+		{
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify({
+				bucket_type: 'Daily',
+				range_filter: {
+					start: getNormalizedDateString(get30DAgo()),
+					end: getNormalizedDateString(new Date()),
+				},
+				sort_by: {
+					order: 'Asc',
+					field: 'BlockTime',
+				},
+			}),
+			method: 'POST',
+		}
+	);
+
+	const data: JITO_SOL_METRICS_ENDPOINT_RESPONSE = await res.json();
+
+	return data;
+}
+
+export type MSOL_METRICS_ENDPOINT_RESPONSE = {
+	total_active_balance: number;
+	available_reserve_balance: number;
+	emergency_cooling_down: number;
+	tvl_sol: number;
+	msol_directed_stake_sol: number;
+	msol_directed_stake_msol: number;
+	mnde_total_supply: number;
+	mnde_circulating_supply: number;
+	validators_count: number;
+	stake_accounts: number;
+	staking_sol_cap: number;
+	m_sol_price: number;
+	avg_staking_apy: number;
+	msol_price_apy_14d: number;
+	msol_price_apy_30d: number;
+	msol_price_apy_90d: number;
+	msol_price_apy_365d: number;
+	reserve_pda: number;
+	treasury_m_sol_amount: number;
+	m_sol_mint_supply: number;
+	m_sol_supply_state: number;
+	liq_pool_sol: number;
+	liq_pool_m_sol: number;
+	liq_pool_value: number;
+	liq_pool_token_supply: number;
+	liq_pool_token_price: number;
+	liq_pool_target: number;
+	liq_pool_min_fee: number;
+	liq_pool_max_fee: number;
+	liq_pool_current_fee: number;
+	liq_pool_treasury_cut: number;
+	liq_pool_cap: number;
+	total_cooling_down: number;
+	last_stake_delta_epoch: number;
+	circulating_ticket_count: number;
+	circulating_ticket_balance: number;
+	reward_fee_bp: number;
+	lido_staking: number;
+	lido_st_sol_price: number;
+	lido_stsol_price_apy_14d: number;
+	lido_stsol_price_apy_30d: number;
+	lido_stsol_price_apy_90d: number;
+	lido_stsol_price_apy_365d: number;
+	stake_delta: number;
+	bot_balance: number;
+	treasury_farm_claim_mnde_balance: number;
+	last_3_epochs_avg_duration_hs: number;
+	mnde_votes_validators: number;
+};
+
+export const fetchMSolMetrics = async () => {
+	const res = await fetch('https://api2.marinade.finance/metrics_json');
+	const data: MSOL_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.supply.length; i++) {
+			const priceInSol = data.tvl[i].data / 10 ** 9 / data.supply[i].data;
+			jitoSolHistoricalPriceInSol.push({
+				price: priceInSol,
+				ts: data.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> {
+	const now = Date.now() / 1000;
+	const timestamps: number[] = [
+		now,
+		...depositRecords
+			.filter((r) => r.marketIndex === marketIndex)
+			.map((r) => r.ts.toNumber()),
+	];
+
+	let lstRatios = new Map<number, number>();
+
+	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();
+			lstRatios.set(timestamp, data);
+		}
+	};
+
+	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;
+	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 ||
+			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 {
+				solEarned = solEarned.add(solAmount);
+			}
+		}
+	}
+
+	const currentLstTokenAmount = await user.getTokenAmount(marketIndex);
+	const currentLstRatio = lstRatios.get(now);
+	const currentLstRatioBN = new BN(currentLstRatio * LAMPORTS_PER_SOL);
+
+	solEarned = solEarned.add(
+		currentLstTokenAmount.mul(currentLstRatioBN).div(LAMPORTS_PRECISION)
+	);
+
+	const currentSOLTokenAmount = await user.getTokenAmount(1);
+	solEarned = solEarned.add(currentSOLTokenAmount);
+
+	return solEarned;
+}
+
+// calculate estimated liquidation price (in LST/SOL) based on target amounts
+export function calculateEstimatedSuperStakeLiquidationPrice(
+	lstDepositAmount: number,
+	lstMaintenanceAssetWeight: number,
+	solBorrowAmount: number,
+	solMaintenanceLiabilityWeight: number,
+	lstPriceRatio: number
+): number {
+	const liquidationDivergence =
+		(solMaintenanceLiabilityWeight * solBorrowAmount) /
+		(lstMaintenanceAssetWeight * lstDepositAmount * lstPriceRatio);
+	const liquidationPrice = lstPriceRatio * 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, 'highlySpeculative')) {
+		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;
+}