@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/node/math/spotMarket.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMaxRemainingDeposit = exports.calculateSpotMarketMarginRatio = exports.castNumberToSpotPrecision = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const types_1 = require("../types");
+const spotBalance_1 = require("./spotBalance");
+const numericConstants_1 = require("../constants/numericConstants");
+const utils_1 = require("./utils");
+function castNumberToSpotPrecision(value, spotMarket) {
+    if (typeof value === 'number') {
+        return (0, utils_1.numberToSafeBN)(value, new anchor_1.BN(Math.pow(10, spotMarket.decimals)));
+    }
+    else {
+        return value.mul(new anchor_1.BN(Math.pow(10, spotMarket.decimals)));
+    }
+}
+exports.castNumberToSpotPrecision = castNumberToSpotPrecision;
+function calculateSpotMarketMarginRatio(market, oraclePrice, marginCategory, size, balanceType, customMarginRatio = 0) {
+    let marginRatio;
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        const assetWeight = (0, spotBalance_1.calculateAssetWeight)(size, oraclePrice, market, marginCategory);
+        marginRatio = numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
+    }
+    else {
+        const liabilityWeight = (0, spotBalance_1.calculateLiabilityWeight)(size, market, marginCategory);
+        marginRatio = liabilityWeight.sub(numericConstants_1.MARGIN_PRECISION).toNumber();
+    }
+    if (marginCategory === 'Initial') {
+        // use lowest leverage between max allowed and optional user custom max
+        return Math.max(marginRatio, customMarginRatio);
+    }
+    return marginRatio;
+}
+exports.calculateSpotMarketMarginRatio = calculateSpotMarketMarginRatio;
+/**
+ * Returns the maximum remaining deposit that can be made to the spot market. If the maxTokenDeposits on the market is zero then there is no limit and this function will also return zero. (so that needs to be checked)
+ * @param market
+ * @returns
+ */
+function calculateMaxRemainingDeposit(market) {
+    const marketMaxTokenDeposits = market.maxTokenDeposits;
+    if (marketMaxTokenDeposits.eq(numericConstants_1.ZERO)) {
+        // If the maxTokenDeposits is set to zero then that means there is no limit. Return the largest number we can to represent infinite available deposit.
+        return numericConstants_1.ZERO;
+    }
+    const totalDepositsTokenAmount = (0, spotBalance_1.getTokenAmount)(market.depositBalance, market, types_1.SpotBalanceType.DEPOSIT);
+    return marketMaxTokenDeposits.sub(totalDepositsTokenAmount);
+}
+exports.calculateMaxRemainingDeposit = calculateMaxRemainingDeposit;

package/lib/node/math/spotPosition.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="bn.js" />
+import { MarginCategory, SpotMarketAccount, SpotPosition } from '../types';
+import { BN } from '@coral-xyz/anchor';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
+export declare function isSpotPositionAvailable(position: SpotPosition): boolean;
+export type OrderFillSimulation = {
+    tokenAmount: BN;
+    ordersValue: BN;
+    tokenValue: BN;
+    weight: BN;
+    weightedTokenValue: BN;
+    freeCollateralContribution: any;
+};
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, strictOraclePrice: StrictOraclePrice, marginCategory: MarginCategory, customMarginRatio?: number): OrderFillSimulation;
+export declare function calculateWeightedTokenValue(tokenAmount: BN, tokenValue: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory, customMarginRatio?: number): {
+    weight: BN;
+    weightedTokenValue: BN;
+};
+export declare function simulateOrderFill(tokenAmount: BN, tokenValue: BN, openOrders: BN, strictOraclePrice: StrictOraclePrice, spotMarket: SpotMarketAccount, marginCategory: MarginCategory, customMarginRatio?: number): OrderFillSimulation;

package/lib/node/math/spotPosition.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateOrderFill = exports.calculateWeightedTokenValue = exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@coral-xyz/anchor");
+const spotBalance_1 = require("./spotBalance");
+function isSpotPositionAvailable(position) {
+    return position.scaledBalance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+}
+exports.isSpotPositionAvailable = isSpotPositionAvailable;
+function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory, customMarginRatio) {
+    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenValue = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
+    if (spotPosition.openBids.eq(numericConstants_1.ZERO) && spotPosition.openAsks.eq(numericConstants_1.ZERO)) {
+        const { weight, weightedTokenValue } = calculateWeightedTokenValue(tokenAmount, tokenValue, strictOraclePrice.current, spotMarketAccount, marginCategory, customMarginRatio);
+        return {
+            tokenAmount,
+            ordersValue: numericConstants_1.ZERO,
+            tokenValue,
+            weight,
+            weightedTokenValue,
+            freeCollateralContribution: weightedTokenValue,
+        };
+    }
+    const bidsSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openBids, strictOraclePrice, spotMarketAccount, marginCategory, customMarginRatio);
+    const asksSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openAsks, strictOraclePrice, spotMarketAccount, marginCategory, customMarginRatio);
+    if (asksSimulation.freeCollateralContribution.lt(bidsSimulation.freeCollateralContribution)) {
+        return asksSimulation;
+    }
+    else {
+        return bidsSimulation;
+    }
+}
+exports.getWorstCaseTokenAmounts = getWorstCaseTokenAmounts;
+function calculateWeightedTokenValue(tokenAmount, tokenValue, oraclePrice, spotMarket, marginCategory, customMarginRatio) {
+    let weight;
+    if (tokenValue.gte(numericConstants_1.ZERO)) {
+        weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, oraclePrice, spotMarket, marginCategory);
+    }
+    else {
+        weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount.abs(), spotMarket, marginCategory);
+    }
+    if (marginCategory === 'Initial' &&
+        customMarginRatio &&
+        spotMarket.marketIndex !== numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+        const userCustomAssetWeight = tokenValue.gte(numericConstants_1.ZERO)
+            ? anchor_1.BN.max(numericConstants_1.ZERO, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.subn(customMarginRatio))
+            : numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION.addn(customMarginRatio);
+        weight = tokenValue.gte(numericConstants_1.ZERO)
+            ? anchor_1.BN.min(weight, userCustomAssetWeight)
+            : anchor_1.BN.max(weight, userCustomAssetWeight);
+    }
+    return {
+        weight: weight,
+        weightedTokenValue: tokenValue
+            .mul(weight)
+            .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION),
+    };
+}
+exports.calculateWeightedTokenValue = calculateWeightedTokenValue;
+function simulateOrderFill(tokenAmount, tokenValue, openOrders, strictOraclePrice, spotMarket, marginCategory, customMarginRatio) {
+    const ordersValue = (0, spotBalance_1.getTokenValue)(openOrders.neg(), spotMarket.decimals, {
+        price: strictOraclePrice.max(),
+    });
+    const tokenAmountAfterFill = tokenAmount.add(openOrders);
+    const tokenValueAfterFill = tokenValue.add(ordersValue.neg());
+    const { weight, weightedTokenValue: weightedTokenValueAfterFill } = calculateWeightedTokenValue(tokenAmountAfterFill, tokenValueAfterFill, strictOraclePrice.current, spotMarket, marginCategory, customMarginRatio);
+    const freeCollateralContribution = weightedTokenValueAfterFill.add(ordersValue);
+    return {
+        tokenAmount: tokenAmountAfterFill,
+        ordersValue: ordersValue,
+        tokenValue: tokenValueAfterFill,
+        weight,
+        weightedTokenValue: weightedTokenValueAfterFill,
+        freeCollateralContribution,
+    };
+}
+exports.simulateOrderFill = simulateOrderFill;

package/lib/node/math/state.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="bn.js" />
+import { StateAccount } from '../types';
+import { BN } from '../';
+export declare function calculateInitUserFee(stateAccount: StateAccount): BN;
+export declare function getMaxNumberOfSubAccounts(stateAccount: StateAccount): BN;

package/lib/node/math/state.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaxNumberOfSubAccounts = exports.calculateInitUserFee = void 0;
+const __1 = require("../");
+function calculateInitUserFee(stateAccount) {
+    const maxInitFee = new __1.BN(stateAccount.maxInitializeUserFee)
+        .mul(__1.LAMPORTS_PRECISION)
+        .divn(100);
+    const targetUtilization = __1.PERCENTAGE_PRECISION.muln(8).divn(10);
+    const accountSpaceUtilization = stateAccount.numberOfSubAccounts
+        .addn(1)
+        .mul(__1.PERCENTAGE_PRECISION)
+        .div(getMaxNumberOfSubAccounts(stateAccount));
+    if (accountSpaceUtilization.gt(targetUtilization)) {
+        return maxInitFee
+            .mul(accountSpaceUtilization.sub(targetUtilization))
+            .div(__1.PERCENTAGE_PRECISION.sub(targetUtilization));
+    }
+    else {
+        return __1.ZERO;
+    }
+}
+exports.calculateInitUserFee = calculateInitUserFee;
+function getMaxNumberOfSubAccounts(stateAccount) {
+    if (stateAccount.maxNumberOfSubAccounts <= 5) {
+        return new __1.BN(stateAccount.maxNumberOfSubAccounts);
+    }
+    return new __1.BN(stateAccount.maxNumberOfSubAccounts).muln(100);
+}
+exports.getMaxNumberOfSubAccounts = getMaxNumberOfSubAccounts;

package/lib/node/math/superStake.d.ts

@@ -0,0 +1,167 @@
+/// <reference types="bn.js" />
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { JupiterClient, QuoteResponse } from '../jupiter/jupiterClient';
+import { DriftClient } from '../driftClient';
+import { BN } from '@coral-xyz/anchor';
+import { User } from '../user';
+import { DepositRecord } from '../types';
+import fetch from 'node-fetch';
+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 declare function fetchBSolMetrics(): Promise<fetch.Response>;
+export declare function fetchBSolDriftEmissions(): Promise<fetch.Response>;
+export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
+    marketIndex: number;
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    price?: number;
+    userAccountPublicKey?: PublicKey;
+    forceMarinade?: boolean;
+    onlyDirectRoutes?: boolean;
+    jupiterQuote?: QuoteResponse;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price?: number;
+}>;
+export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    price?: number;
+    userAccountPublicKey?: PublicKey;
+    forceMarinade?: boolean;
+    onlyDirectRoutes?: boolean;
+    jupiterQuote?: QuoteResponse;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price: number;
+}>;
+export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, jupiterQuote, }: {
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    userAccountPublicKey?: PublicKey;
+    onlyDirectRoutes?: boolean;
+    jupiterQuote?: QuoteResponse;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price?: number;
+}>;
+/**
+ * Finds best Jupiter 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 declare function findBestLstSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }: {
+    amount: BN;
+    lstMint: PublicKey;
+    lstMarketIndex: number;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    userAccountPublicKey?: PublicKey;
+    onlyDirectRoutes?: boolean;
+    jupiterQuote?: QuoteResponse;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+}>;
+export type JITO_SOL_METRICS_ENDPOINT_RESPONSE = {
+    tvl: {
+        data: number;
+        date: string;
+    }[];
+    supply: {
+        data: number;
+        date: string;
+    }[];
+    apy: {
+        data: number;
+        date: string;
+    }[];
+};
+export declare function fetchJitoSolMetrics(): Promise<JITO_SOL_METRICS_ENDPOINT_RESPONSE>;
+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 declare const fetchMSolMetrics: () => Promise<MSOL_METRICS_ENDPOINT_RESPONSE>;
+export declare function calculateSolEarned({ marketIndex, user, depositRecords, }: {
+    marketIndex: number;
+    user: User;
+    depositRecords: DepositRecord[];
+}): Promise<BN>;
+export declare function calculateEstimatedSuperStakeLiquidationPrice(lstDepositAmount: number, lstMaintenanceAssetWeight: number, solBorrowAmount: number, solMaintenanceLiabilityWeight: number, lstPriceRatio: number): number;

package/lib/node/math/superStake.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateEstimatedSuperStakeLiquidationPrice = exports.calculateSolEarned = exports.fetchMSolMetrics = exports.fetchJitoSolMetrics = exports.findBestLstSuperStakeIxs = exports.findBestJitoSolSuperStakeIxs = exports.findBestMSolSuperStakeIxs = exports.findBestSuperStakeIxs = exports.fetchBSolDriftEmissions = exports.fetchBSolMetrics = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const marinade_1 = require("../marinade");
+const anchor_1 = require("@coral-xyz/anchor");
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const utils_1 = require("./utils");
+async function fetchBSolMetrics() {
+    return await (0, node_fetch_1.default)('https://stake.solblaze.org/api/v1/stats');
+}
+exports.fetchBSolMetrics = fetchBSolMetrics;
+async function fetchBSolDriftEmissions() {
+    return await (0, node_fetch_1.default)('https://stake.solblaze.org/api/v1/drift_emissions');
+}
+exports.fetchBSolDriftEmissions = fetchBSolDriftEmissions;
+async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }) {
+    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}`);
+    }
+}
+exports.findBestSuperStakeIxs = findBestSuperStakeIxs;
+async function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }) {
+    if (!price) {
+        const marinadeProgram = (0, marinade_1.getMarinadeFinanceProgram)(driftClient.provider);
+        price = await (0, marinade_1.getMarinadeMSolPrice)(marinadeProgram);
+    }
+    const solSpotMarketAccount = driftClient.getSpotMarketAccount(1);
+    const mSolSpotMarketAccount = driftClient.getSpotMarketAccount(2);
+    let jupiterPrice;
+    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,
+        };
+    }
+}
+exports.findBestMSolSuperStakeIxs = findBestMSolSuperStakeIxs;
+async function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, jupiterQuote, }) {
+    return await findBestLstSuperStakeIxs({
+        amount,
+        jupiterClient,
+        driftClient,
+        userAccountPublicKey,
+        onlyDirectRoutes,
+        lstMint: driftClient.getSpotMarketAccount(6).mint,
+        lstMarketIndex: 6,
+        jupiterQuote,
+    });
+}
+exports.findBestJitoSolSuperStakeIxs = findBestJitoSolSuperStakeIxs;
+/**
+ * Finds best Jupiter 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
+ */
+async function findBestLstSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }) {
+    const { ixs, lookupTables } = await driftClient.getJupiterSwapIxV6({
+        inMarketIndex: 1,
+        outMarketIndex: lstMarketIndex,
+        jupiterClient,
+        amount,
+        userAccountPublicKey,
+        onlyDirectRoutes,
+        quote: jupiterQuote,
+    });
+    return {
+        method: 'jupiter',
+        ixs,
+        lookupTables,
+        // price: jupiterPrice,
+    };
+}
+exports.findBestLstSuperStakeIxs = findBestLstSuperStakeIxs;
+/**
+ * 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) => {
+    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;
+};
+async function fetchJitoSolMetrics() {
+    const res = await (0, node_fetch_1.default)('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 = await res.json();
+    return data;
+}
+exports.fetchJitoSolMetrics = fetchJitoSolMetrics;
+const fetchMSolMetrics = async () => {
+    const res = await (0, node_fetch_1.default)('https://api2.marinade.finance/metrics_json');
+    const data = await res.json();
+    return data;
+};
+exports.fetchMSolMetrics = fetchMSolMetrics;
+const getJitoSolHistoricalPriceMap = async (timestamps) => {
+    try {
+        const data = await fetchJitoSolMetrics();
+        const jitoSolHistoricalPriceMap = new Map();
+        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) => (0, utils_1.checkSameDate)(p.ts, dateString));
+            if (price) {
+                jitoSolHistoricalPriceMap.set(timestamp, price.price);
+            }
+        }
+        return jitoSolHistoricalPriceMap;
+    }
+    catch (err) {
+        console.error(err);
+        return undefined;
+    }
+};
+async function calculateSolEarned({ marketIndex, user, depositRecords, }) {
+    const now = Date.now() / 1000;
+    const timestamps = [
+        now,
+        ...depositRecords
+            .filter((r) => r.marketIndex === marketIndex)
+            .map((r) => r.ts.toNumber()),
+    ];
+    let lstRatios = new Map();
+    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 (0, node_fetch_1.default)(url);
+        if (response.status === 200) {
+            const data = await response.json();
+            lstRatios.set(timestamp, data);
+        }
+    };
+    const getBSolPrice = async (timestamps) => {
+        var _a, _b;
+        // 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());
+            const bSolRatio = (_b = (_a = data === null || data === void 0 ? void 0 : data.stats) === null || _a === void 0 ? void 0 : _a.conversion) === null || _b === void 0 ? void 0 : _b.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 = numericConstants_1.ZERO;
+    for (const record of depositRecords) {
+        if (record.marketIndex === 1) {
+            if ((0, types_1.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 anchor_1.BN(lstRatio * web3_js_1.LAMPORTS_PER_SOL);
+            const solAmount = record.amount.mul(lstRatioBN).div(numericConstants_1.LAMPORTS_PRECISION);
+            if ((0, types_1.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 anchor_1.BN(currentLstRatio * web3_js_1.LAMPORTS_PER_SOL);
+    solEarned = solEarned.add(currentLstTokenAmount.mul(currentLstRatioBN).div(numericConstants_1.LAMPORTS_PRECISION));
+    const currentSOLTokenAmount = await user.getTokenAmount(1);
+    solEarned = solEarned.add(currentSOLTokenAmount);
+    return solEarned;
+}
+exports.calculateSolEarned = calculateSolEarned;
+// calculate estimated liquidation price (in LST/SOL) based on target amounts
+function calculateEstimatedSuperStakeLiquidationPrice(lstDepositAmount, lstMaintenanceAssetWeight, solBorrowAmount, solMaintenanceLiabilityWeight, lstPriceRatio) {
+    const liquidationDivergence = (solMaintenanceLiabilityWeight * solBorrowAmount) /
+        (lstMaintenanceAssetWeight * lstDepositAmount * lstPriceRatio);
+    const liquidationPrice = lstPriceRatio * liquidationDivergence;
+    return liquidationPrice;
+}
+exports.calculateEstimatedSuperStakeLiquidationPrice = calculateEstimatedSuperStakeLiquidationPrice;

package/lib/node/math/tiers.d.ts

@@ -0,0 +1,4 @@
+import { PerpMarketAccount, SpotMarketAccount } from '../types';
+export declare function getPerpMarketTierNumber(perpMarket: PerpMarketAccount): number;
+export declare function getSpotMarketTierNumber(spotMarket: SpotMarketAccount): number;
+export declare function perpTierIsAsSafeAs(perpTier: number, otherPerpTier: number, otherSpotTier: number): boolean;