@drift-labs/sdk 2.54.0-beta.0 → 2.54.0-beta.10

package/VERSION

@@ -1 +1 @@
-2.54.0-beta.0
+2.54.0-beta.10

package/lib/accounts/pollingInsuranceFundStakeAccountSubscriber.js

@@ -22,7 +22,6 @@ class PollingInsuranceFundStakeAccountSubscriber {
             };
         }
         await this.addToAccountLoader();
-        await this.fetchIfUnloaded();
         if (this.doesAccountExist()) {
             this.eventEmitter.emit('update');
         }

package/lib/constants/perpMarkets.js

@@ -224,6 +224,16 @@ exports.DevnetPerpMarkets = [
         launchTs: 1703173331000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'AVAX',
+        category: ['Rollup', 'Infra'],
+        symbol: 'AVAX-PERP',
+        baseAssetSymbol: 'AVAX',
+        marketIndex: 22,
+        oracle: new web3_js_1.PublicKey('FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz'),
+        launchTs: 1704209558000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.MainnetPerpMarkets = [
     {
@@ -446,6 +456,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1703173331000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'AVAX',
+        category: ['Rollup', 'Infra'],
+        symbol: 'AVAX-PERP',
+        baseAssetSymbol: 'AVAX',
+        marketIndex: 22,
+        oracle: new web3_js_1.PublicKey('Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU'),
+        launchTs: 1704209558000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/driftClient.d.ts

@@ -284,10 +284,11 @@ export declare class DriftClient {
      * @param cancelExistingOrders - Builds and returns an extra transaciton to cancel the existing orders in the same perp market. Intended use is to auto-cancel TP/SL orders when closing a position. Ignored if orderParams.marketType is not MarketType.PERP
      * @returns
      */
-    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean): Promise<{
+    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
         txSig: TransactionSignature;
         signedFillTx?: Transaction;
         signedCancelExistingOrdersTx?: Transaction;
+        signedSettlePnlTx?: Transaction;
     }>;
     placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
@@ -310,7 +311,7 @@ export declare class DriftClient {
         direction?: PositionDirection;
     }, placeOrderParams: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    getPlaceOrdersIx(params: OrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
+    getPlaceOrdersIx(params: OptionalOrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
     fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, fillerPublicKey?: number): Promise<TransactionSignature>;
     getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerSubAccountId?: number): Promise<TransactionInstruction>;
     getRevertFillIx(fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
@@ -427,6 +428,11 @@ export declare class DriftClient {
     updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
     getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
+        txSig: TransactionSignature;
+        signedCancelExistingOrdersTx?: Transaction;
+        signedSettlePnlTx?: Transaction;
+    }>;
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;

package/lib/driftClient.js

@@ -1419,35 +1419,47 @@ class DriftClient {
      * @param cancelExistingOrders - Builds and returns an extra transaciton to cancel the existing orders in the same perp market. Intended use is to auto-cancel TP/SL orders when closing a position. Ignored if orderParams.marketType is not MarketType.PERP
      * @returns
      */
-    async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders) {
+    async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders, settlePnl) {
         const marketIndex = orderParams.marketIndex;
         const orderId = userAccount.nextOrderId;
-        const bracketOrderIxs = [];
-        const placePerpOrderIx = await this.getPlacePerpOrderIx(orderParams, userAccount.subAccountId);
-        for (const bracketOrderParams of bracketOrdersParams) {
-            const placeBracketOrderIx = await this.getPlacePerpOrderIx(bracketOrderParams, userAccount.subAccountId);
-            bracketOrderIxs.push(placeBracketOrderIx);
-        }
-        let cancelOrdersIx;
+        const ordersIx = await this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
+        /* Cancel open orders in market if requested */
         let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
-            cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
+            const cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
             //@ts-ignore
             cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
         }
+        /* Settle PnL after fill if requested */
+        let settlePnlTx;
+        if (settlePnl && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            const settlePnlIx = await this.settlePNLIx(userAccountPublicKey, userAccount, marketIndex);
+            //@ts-ignore
+            settlePnlTx = await this.buildTransaction([settlePnlIx], txParams, this.txVersion);
+        }
         // use versioned transactions if there is a lookup table account and wallet is compatible
         if (this.txVersion === 0) {
-            const versionedMarketOrderTx = await this.buildTransaction([placePerpOrderIx].concat(bracketOrderIxs), txParams, 0);
+            const versionedMarketOrderTx = await this.buildTransaction(ordersIx, txParams, 0);
             const fillPerpOrderIx = await this.getFillPerpOrderIx(userAccountPublicKey, userAccount, {
                 orderId,
                 marketIndex,
             }, makerInfo, referrerInfo, userAccount.subAccountId);
             const versionedFillTx = await this.buildTransaction([fillPerpOrderIx], txParams, 0);
-            const [signedVersionedMarketOrderTx, signedVersionedFillTx, signedCancelExistingOrdersTx,] = await this.provider.wallet.signAllTransactions([
+            const allPossibleTxs = [
                 versionedMarketOrderTx,
                 versionedFillTx,
                 cancelExistingOrdersTx,
-            ].filter((tx) => tx !== undefined));
+                settlePnlTx,
+            ];
+            const txKeys = [
+                'signedVersionedMarketOrderTx',
+                'signedVersionedFillTx',
+                'signedCancelExistingOrdersTx',
+                'signedSettlePnlTx',
+            ];
+            const { signedVersionedMarketOrderTx, signedVersionedFillTx, signedCancelExistingOrdersTx, signedSettlePnlTx, } = await (0, utils_1.getSignedTransactionMap)(
+            //@ts-ignore
+            this.provider.wallet, allPossibleTxs, txKeys);
             const { txSig, slot } = await this.txSender.sendRawTransaction(signedVersionedMarketOrderTx.serialize(), this.opts);
             this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
             return {
@@ -1456,13 +1468,12 @@ class DriftClient {
                 signedFillTx: signedVersionedFillTx,
                 // @ts-ignore
                 signedCancelExistingOrdersTx,
+                // @ts-ignore
+                signedSettlePnlTx,
             };
         }
         else {
-            const marketOrderTx = (0, utils_1.wrapInTx)(placePerpOrderIx, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice);
-            if (bracketOrderIxs.length > 0) {
-                marketOrderTx.add(...bracketOrderIxs);
-            }
+            const marketOrderTx = (0, utils_1.wrapInTx)(ordersIx, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice);
             // Apply the latest blockhash to the txs so that we can sign before sending them
             const currentBlockHash = (await this.connection.getLatestBlockhash('finalized')).blockhash;
             marketOrderTx.recentBlockhash = currentBlockHash;
@@ -1471,10 +1482,33 @@ class DriftClient {
                 cancelExistingOrdersTx.recentBlockhash = currentBlockHash;
                 cancelExistingOrdersTx.feePayer = userAccount.authority;
             }
-            const [signedMarketOrderTx, signedCancelExistingOrdersTx] = await this.provider.wallet.signAllTransactions([marketOrderTx, cancelExistingOrdersTx].filter((tx) => tx !== undefined));
+            if (settlePnlTx) {
+                settlePnlTx.recentBlockhash = currentBlockHash;
+                settlePnlTx.feePayer = userAccount.authority;
+            }
+            const allPossibleTxs = [
+                marketOrderTx,
+                cancelExistingOrdersTx,
+                settlePnlTx,
+            ];
+            const txKeys = [
+                'signedMarketOrderTx',
+                'signedCancelExistingOrdersTx',
+                'signedSettlePnlTx',
+            ];
+            const { signedMarketOrderTx, signedCancelExistingOrdersTx, signedSettlePnlTx, } = await (0, utils_1.getSignedTransactionMap)(
+            //@ts-ignore
+            this.provider.wallet, allPossibleTxs, txKeys);
             const { txSig, slot } = await this.sendTransaction(signedMarketOrderTx, [], this.opts, true);
             this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
-            return { txSig, signedFillTx: undefined, signedCancelExistingOrdersTx };
+            return {
+                txSig,
+                signedFillTx: undefined,
+                //@ts-ignore
+                signedCancelExistingOrdersTx,
+                //@ts-ignore
+                signedSettlePnlTx,
+            };
         }
     }
     async placePerpOrder(orderParams, txParams, subAccountId) {
@@ -1708,7 +1742,8 @@ class DriftClient {
             readableSpotMarketIndexes,
             useMarketLastSlotCache: true,
         });
-        return await this.program.instruction.placeOrders(params, {
+        const formattedParams = params.map((item) => (0, orderParams_1.getOrderParams)(item));
+        return await this.program.instruction.placeOrders(formattedParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user,
@@ -2168,7 +2203,6 @@ class DriftClient {
                 slippageBps,
                 swapMode,
                 onlyDirectRoutes,
-                excludeDexes: ['Raydium CLMM'], // temp exclude to workaround bug with raydium clmm
             });
             quote = fetchedQuote;
         }
@@ -2412,6 +2446,47 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
+    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl) {
+        let cancelExistingOrdersTx;
+        if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            const cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, subAccountId);
+            //@ts-ignore
+            cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
+        }
+        /* Settle PnL after fill if requested */
+        let settlePnlTx;
+        if (settlePnl && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            const userAccountPublicKey = await this.getUserAccountPublicKey(subAccountId);
+            const settlePnlIx = await this.settlePNLIx(userAccountPublicKey, this.getUserAccount(subAccountId), orderParams.marketIndex);
+            //@ts-ignore
+            settlePnlTx = await this.buildTransaction([settlePnlIx], txParams, this.txVersion);
+        }
+        const ixs = [];
+        const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId);
+        ixs.push(placeAndTakeIx);
+        if (bracketOrdersParams.length > 0) {
+            const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
+            ixs.push(bracketOrdersIx);
+        }
+        const placeAndTakeTx = await this.buildTransaction(ixs, txParams);
+        const allPossibleTxs = [
+            placeAndTakeTx,
+            cancelExistingOrdersTx,
+            settlePnlTx,
+        ];
+        const txKeys = [
+            'signedPlaceAndTakeTx',
+            'signedCancelExistingOrdersTx',
+            'signedSettlePnlTx',
+        ];
+        const { signedPlaceAndTakeTx, signedCancelExistingOrdersTx, signedSettlePnlTx, } = await (0, utils_1.getSignedTransactionMap)(
+        //@ts-ignore
+        this.provider.wallet, allPossibleTxs, txKeys);
+        const { txSig, slot } = await this.sendTransaction(signedPlaceAndTakeTx, [], this.opts, true);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+        //@ts-ignore
+        return { txSig, signedCancelExistingOrdersTx, signedSettlePnlTx };
+    }
     async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();

package/lib/events/webSocketLogProvider.js

@@ -44,6 +44,9 @@ class WebSocketLogProvider {
                 }
                 this.reconnectAttempts = 0;
             }
+            if (logs.err !== null) {
+                return;
+            }
             callback(logs.signature, ctx.slot, logs.logs, undefined);
         }, this.commitment);
     }

package/lib/idl/drift.json

@@ -8524,7 +8524,13 @@
                 "kind": "enum",
                 "variants": [
                     {
-                        "name": "Standard"
+                        "name": "Standard",
+                        "fields": [
+                            {
+                                "name": "track_open_orders_fraction",
+                                "type": "bool"
+                            }
+                        ]
                     },
                     {
                         "name": "Liquidation",

package/lib/jupiter/jupiterClient.d.ts

@@ -195,6 +195,12 @@ export interface QuoteResponse {
      * @memberof QuoteResponse
      */
     timeTaken?: number;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    error?: string;
 }
 export declare class JupiterClient {
     url: string;

package/lib/jupiter/jupiterClient.js

@@ -44,7 +44,7 @@ class JupiterClient {
      * @param onlyDirectRoutes whether to only return direct routes
      */
     async getQuote({ inputMint, outputMint, amount, maxAccounts = 50, // 50 is an estimated amount with buffer
-    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes = [], }) {
+    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes, }) {
         const params = new URLSearchParams({
             inputMint: inputMint.toString(),
             outputMint: outputMint.toString(),
@@ -53,7 +53,7 @@ class JupiterClient {
             swapMode,
             onlyDirectRoutes: onlyDirectRoutes.toString(),
             maxAccounts: maxAccounts.toString(),
-            excludeDexes: excludeDexes.join(','),
+            ...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
         }).toString();
         const quote = await (await (0, node_fetch_1.default)(`${this.url}/v6/quote?${params}`)).json();
         return quote;

package/lib/math/funding.js

@@ -6,6 +6,7 @@ const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
 const oracles_1 = require("./oracles");
+const utils_1 = require("./utils");
 function calculateLiveMarkTwap(market, oraclePriceData, markPrice, now, period = new anchor_1.BN(3600)) {
     now = now || new anchor_1.BN((Date.now() / 1000).toFixed(0));
     const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
@@ -73,7 +74,9 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, markPri
     // }
     const twapSpread = markTwap.sub(oracleTwap);
     const twapSpreadWithOffset = twapSpread.add(oracleTwap.abs().div(numericConstants_1.FUNDING_RATE_OFFSET_DENOMINATOR));
-    const twapSpreadPct = twapSpreadWithOffset
+    const maxSpread = getMaxPriceDivergenceForFundingRate(market, oracleTwap);
+    const clampedSpreadWithOffset = (0, utils_1.clampBN)(twapSpreadWithOffset, maxSpread.mul(new anchor_1.BN(-1)), maxSpread);
+    const twapSpreadPct = clampedSpreadWithOffset
         .mul(numericConstants_1.PRICE_PRECISION)
         .mul(new anchor_1.BN(100))
         .div(oracleTwap);
@@ -135,6 +138,26 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, markPri
     return [markTwap, oracleTwap, lowerboundEst, cappedAltEst, interpEst];
 }
 exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+function getMaxPriceDivergenceForFundingRate(market, oracleTwap) {
+    if ((0, types_1.isVariant)(market.contractTier, 'a')) {
+        return oracleTwap.divn(33);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'b')) {
+        return oracleTwap.divn(33);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'c')) {
+        return oracleTwap.divn(20);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'speculative')) {
+        return oracleTwap.divn(10);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'isolated')) {
+        return oracleTwap.divn(10);
+    }
+    else {
+        return oracleTwap.divn(10);
+    }
+}
 /**
  *
  * @param market

package/lib/math/oracles.js

@@ -25,8 +25,8 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(oraclePriceData.price)
         .gt(oracleGuardRails.validity.confidenceIntervalMaxSize);
-    const oracleIsStale = oraclePriceData.slot
-        .sub(new index_1.BN(slot))
+    const oracleIsStale = new index_1.BN(slot)
+        .sub(oraclePriceData.slot)
         .gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
     return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
         oracleIsStale ||

package/lib/math/superStake.d.ts

@@ -111,6 +111,57 @@ export type JITO_SOL_METRICS_ENDPOINT_RESPONSE = {
     };
 };
 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;

package/lib/math/superStake.js

@@ -3,7 +3,7 @@ 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.fetchJitoSolMetrics = exports.findBestLstSuperStakeIxs = exports.findBestJitoSolSuperStakeIxs = exports.findBestMSolSuperStakeIxs = exports.findBestSuperStakeIxs = exports.fetchBSolDriftEmissions = exports.fetchBSolMetrics = void 0;
+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");
@@ -194,6 +194,12 @@ async function fetchJitoSolMetrics() {
     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();
@@ -227,7 +233,9 @@ async function calculateSolEarned({ marketIndex, user, depositRecords, }) {
     const now = Date.now() / 1000;
     const timestamps = [
         now,
-        ...depositRecords.map((r) => r.ts.toNumber()),
+        ...depositRecords
+            .filter((r) => r.marketIndex === marketIndex)
+            .map((r) => r.ts.toNumber()),
     ];
     let lstRatios = new Map();
     const getMsolPrice = async (timestamp) => {

package/lib/priorityFee/averageOverSlotsStrategy.d.ts

@@ -1,10 +1,5 @@
 import { PriorityFeeStrategy } from './types';
 export declare class AverageOverSlotsStrategy implements PriorityFeeStrategy {
-    private lookbackSlots;
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots?: number);
     calculate(samples: {
         slot: number;
         prioritizationFee: number;

package/lib/priorityFee/averageOverSlotsStrategy.js

@@ -2,27 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AverageOverSlotsStrategy = void 0;
 class AverageOverSlotsStrategy {
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots = 10) {
-        this.lookbackSlots = lookbackSlots;
-    }
     calculate(samples) {
         if (samples.length === 0) {
             return 0;
         }
-        const stopSlot = samples[0].slot - this.lookbackSlots;
         let runningSumFees = 0;
-        let countFees = 0;
         for (let i = 0; i < samples.length; i++) {
-            if (samples[i].slot <= stopSlot) {
-                return runningSumFees / countFees;
-            }
             runningSumFees += samples[i].prioritizationFee;
-            countFees++;
         }
-        return runningSumFees / countFees;
+        return runningSumFees / samples.length;
     }
 }
 exports.AverageOverSlotsStrategy = AverageOverSlotsStrategy;

package/lib/priorityFee/maxOverSlotsStrategy.d.ts

@@ -1,10 +1,5 @@
 import { PriorityFeeStrategy } from './types';
 export declare class MaxOverSlotsStrategy implements PriorityFeeStrategy {
-    private lookbackSlots;
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots?: number);
     calculate(samples: {
         slot: number;
         prioritizationFee: number;

package/lib/priorityFee/maxOverSlotsStrategy.js

@@ -2,26 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxOverSlotsStrategy = void 0;
 class MaxOverSlotsStrategy {
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots = 10) {
-        this.lookbackSlots = lookbackSlots;
-    }
     calculate(samples) {
         if (samples.length === 0) {
             return 0;
         }
         // Assuming samples are sorted in descending order of slot.
-        const stopSlot = samples[0].slot - this.lookbackSlots;
         let currMaxFee = samples[0].prioritizationFee;
         for (let i = 0; i < samples.length; i++) {
-            if (samples[i].slot <= stopSlot) {
-                return currMaxFee;
-            }
-            if (samples[i].prioritizationFee > currMaxFee) {
-                currMaxFee = samples[i].prioritizationFee;
-            }
+            currMaxFee = Math.max(samples[i].prioritizationFee, currMaxFee);
         }
         return currMaxFee;
     }

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -9,13 +9,17 @@ export declare class PriorityFeeSubscriber {
     customStrategy?: PriorityFeeStrategy;
     averageStrategy: AverageOverSlotsStrategy;
     maxStrategy: MaxOverSlotsStrategy;
+    lookbackDistance: number;
     intervalId?: ReturnType<typeof setTimeout>;
     latestPriorityFee: number;
-    lastStrategyResult: number;
     lastCustomStrategyResult: number;
     lastAvgStrategyResult: number;
     lastMaxStrategyResult: number;
     lastSlotSeen: number;
+    /**
+     * @param props
+     * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
+     */
     constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck, }: {
         connection: Connection;
         frequencyMs: number;
@@ -23,9 +27,6 @@ export declare class PriorityFeeSubscriber {
         customStrategy?: PriorityFeeStrategy;
         slotsToCheck?: number;
     });
-    get avgPriorityFee(): number;
-    get maxPriorityFee(): number;
-    get customPriorityFee(): number;
     subscribe(): Promise<void>;
     load(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -4,11 +4,14 @@ exports.PriorityFeeSubscriber = void 0;
 const averageOverSlotsStrategy_1 = require("./averageOverSlotsStrategy");
 const maxOverSlotsStrategy_1 = require("./maxOverSlotsStrategy");
 class PriorityFeeSubscriber {
+    /**
+     * @param props
+     * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
+     */
     constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck = 10, }) {
         this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
         this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy();
         this.latestPriorityFee = 0;
-        this.lastStrategyResult = 0;
         this.lastCustomStrategyResult = 0;
         this.lastAvgStrategyResult = 0;
         this.lastMaxStrategyResult = 0;
@@ -16,25 +19,13 @@ class PriorityFeeSubscriber {
         this.connection = connection;
         this.frequencyMs = frequencyMs;
         this.addresses = addresses;
-        if (slotsToCheck) {
-            this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy(slotsToCheck);
-            this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy(slotsToCheck);
+        if (!customStrategy) {
+            this.customStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
         }
-        if (customStrategy) {
+        else {
             this.customStrategy = customStrategy;
         }
-    }
-    get avgPriorityFee() {
-        return Math.floor(this.lastAvgStrategyResult);
-    }
-    get maxPriorityFee() {
-        return Math.floor(this.lastMaxStrategyResult);
-    }
-    get customPriorityFee() {
-        if (!this.customStrategy) {
-            console.error('Custom strategy not set');
-        }
-        return Math.floor(this.lastCustomStrategyResult);
+        this.lookbackDistance = slotsToCheck;
     }
     async subscribe() {
         if (this.intervalId) {
@@ -45,19 +36,22 @@ class PriorityFeeSubscriber {
     async load() {
         // @ts-ignore
         const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
-        // getRecentPrioritizationFees returns results unsorted
         const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
         if (!results.length)
             return;
+        // # Sort and filter results based on the slot lookback setting
         const descResults = results.sort((a, b) => b.slot - a.slot);
         const mostRecentResult = descResults[0];
+        const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+        const resultsToUse = descResults.filter((result) => result.slot >= cutoffSlot);
+        // # Handle results
         this.latestPriorityFee = mostRecentResult.prioritizationFee;
         this.lastSlotSeen = mostRecentResult.slot;
-        this.lastAvgStrategyResult = this.averageStrategy.calculate(descResults);
-        this.lastMaxStrategyResult = this.maxStrategy.calculate(descResults);
+        this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
+        this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
         if (this.customStrategy) {
             this.lastCustomStrategyResult =
-                this.customStrategy.calculate(descResults);
+                this.customStrategy.calculate(resultsToUse);
         }
     }
     async unsubscribe() {