@drift-labs/sdk 2.41.0-beta.0 → 2.41.0-beta.2

package/lib/math/amm.js

@@ -253,8 +253,13 @@ function calculateVolSpreadBN(lastOracleConfPct, reservePrice, markStd, oracleSt
     const clampMax = numericConstants_1.PERCENTAGE_PRECISION.mul(new anchor_1.BN(16)).div(new anchor_1.BN(10));
     const longVolSpreadFactor = (0, __1.clampBN)(longIntensity.mul(numericConstants_1.PERCENTAGE_PRECISION).div(anchor_1.BN.max(numericConstants_1.ONE, volume24H)), clampMin, clampMax);
     const shortVolSpreadFactor = (0, __1.clampBN)(shortIntensity.mul(numericConstants_1.PERCENTAGE_PRECISION).div(anchor_1.BN.max(numericConstants_1.ONE, volume24H)), clampMin, clampMax);
-    const longVolSpread = anchor_1.BN.max(lastOracleConfPct, volSpread.mul(longVolSpreadFactor).div(numericConstants_1.PERCENTAGE_PRECISION));
-    const shortVolSpread = anchor_1.BN.max(lastOracleConfPct, volSpread.mul(shortVolSpreadFactor).div(numericConstants_1.PERCENTAGE_PRECISION));
+    // only consider confidence interval at full value when above 25 bps
+    let confComponent = lastOracleConfPct;
+    if (lastOracleConfPct.lte(numericConstants_1.PRICE_PRECISION.div(new anchor_1.BN(400)))) {
+        confComponent = lastOracleConfPct.div(new anchor_1.BN(10));
+    }
+    const longVolSpread = anchor_1.BN.max(confComponent, volSpread.mul(longVolSpreadFactor).div(numericConstants_1.PERCENTAGE_PRECISION));
+    const shortVolSpread = anchor_1.BN.max(confComponent, volSpread.mul(shortVolSpreadFactor).div(numericConstants_1.PERCENTAGE_PRECISION));
     return [longVolSpread, shortVolSpread];
 }
 exports.calculateVolSpreadBN = calculateVolSpreadBN;

package/lib/math/auction.d.ts

@@ -1,7 +1,18 @@
-import { Order } from '../types';
+import { Order, PositionDirection } from '../types';
 import { BN } from '../.';
 export declare function isAuctionComplete(order: Order, slot: number): boolean;
 export declare function isFallbackAvailableLiquiditySource(order: Order, minAuctionDuration: number, slot: number): boolean;
 export declare function getAuctionPrice(order: Order, slot: number, oraclePrice: BN): BN;
 export declare function getAuctionPriceForFixedAuction(order: Order, slot: number): BN;
 export declare function getAuctionPriceForOracleOffsetAuction(order: Order, slot: number, oraclePrice: BN): BN;
+export declare function deriveOracleAuctionParams({ direction, oraclePrice, auctionStartPrice, auctionEndPrice, limitPrice, }: {
+    direction: PositionDirection;
+    oraclePrice: BN;
+    auctionStartPrice: BN;
+    auctionEndPrice: BN;
+    limitPrice: BN;
+}): {
+    auctionStartPrice: BN;
+    auctionEndPrice: BN;
+    oraclePriceOffset: number;
+};

package/lib/math/auction.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAuctionPriceForOracleOffsetAuction = exports.getAuctionPriceForFixedAuction = exports.getAuctionPrice = exports.isFallbackAvailableLiquiditySource = exports.isAuctionComplete = void 0;
+exports.deriveOracleAuctionParams = exports.getAuctionPriceForOracleOffsetAuction = exports.getAuctionPriceForFixedAuction = exports.getAuctionPrice = exports.isFallbackAvailableLiquiditySource = exports.isAuctionComplete = void 0;
 const types_1 = require("../types");
 const _1 = require("../.");
 function isAuctionComplete(order, slot) {
@@ -89,3 +89,24 @@ function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
     return oraclePrice.add(priceOffset);
 }
 exports.getAuctionPriceForOracleOffsetAuction = getAuctionPriceForOracleOffsetAuction;
+function deriveOracleAuctionParams({ direction, oraclePrice, auctionStartPrice, auctionEndPrice, limitPrice, }) {
+    let oraclePriceOffset = limitPrice.sub(oraclePrice);
+    if (oraclePriceOffset.eq(_1.ZERO)) {
+        oraclePriceOffset = (0, types_1.isVariant)(direction, 'long')
+            ? auctionEndPrice.sub(oraclePrice).add(_1.ONE)
+            : auctionEndPrice.sub(oraclePrice).sub(_1.ONE);
+    }
+    let oraclePriceOffsetNum;
+    try {
+        oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+    }
+    catch (e) {
+        oraclePriceOffsetNum = 0;
+    }
+    return {
+        auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+        auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+        oraclePriceOffset: oraclePriceOffsetNum,
+    };
+}
+exports.deriveOracleAuctionParams = deriveOracleAuctionParams;

package/lib/math/market.js

@@ -130,12 +130,10 @@ exports.calculateNetUserPnlImbalance = calculateNetUserPnlImbalance;
 function calculateAvailablePerpLiquidity(market, oraclePriceData, dlob, slot) {
     let [bids, asks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
     asks = asks.abs();
-    const bidPrice = calculateBidPrice(market, oraclePriceData);
-    const askPrice = calculateAskPrice(market, oraclePriceData);
-    for (const bid of dlob.getMakerLimitBids(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, askPrice)) {
+    for (const bid of dlob.getRestingLimitBids(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData)) {
         bids = bids.add(bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled));
     }
-    for (const ask of dlob.getMakerLimitAsks(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, bidPrice)) {
+    for (const ask of dlob.getRestingLimitAsks(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData)) {
         asks = asks.add(ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled));
     }
     return {

package/lib/math/superStake.d.ts

@@ -4,11 +4,12 @@ import { DriftClient } from '../driftClient';
 import { BN } from '@coral-xyz/anchor';
 import { User } from '../user';
 import { DepositRecord } from '../types';
-export declare function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, marinadePrice, forceMarinade, onlyDirectRoutes, }: {
+export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, }: {
+    marketIndex: number;
     amount: BN;
     jupiterClient: JupiterClient;
     driftClient: DriftClient;
-    marinadePrice?: number;
+    price?: number;
     userAccountPublicKey?: PublicKey;
     forceMarinade?: boolean;
     onlyDirectRoutes?: boolean;
@@ -18,8 +19,54 @@ export declare function findBestSuperStakeIxs({ amount, jupiterClient, driftClie
     method: 'jupiter' | 'marinade';
     price: number;
 }>;
-export declare function calculateSolEarned({ user, depositRecords, }: {
+export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, }: {
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    price?: number;
+    userAccountPublicKey?: PublicKey;
+    forceMarinade?: boolean;
+    onlyDirectRoutes?: boolean;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price: number;
+}>;
+export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, }: {
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    userAccountPublicKey?: PublicKey;
+    onlyDirectRoutes?: boolean;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price: number;
+}>;
+export type JITO_SOL_METRICS_ENDPOINT_RESPONSE = {
+    data: {
+        getStakePoolStats: {
+            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 declare function calculateSolEarned({ marketIndex, user, depositRecords, }: {
+    marketIndex: number;
     user: User;
     depositRecords: DepositRecord[];
 }): Promise<BN>;
-export declare function calculateEstimatedSuperStakeLiquidationPrice(msolDepositAmount: number, msolMaintenanceAssetWeight: number, solBorrowAmount: number, solMaintenanceLiabilityWeight: number, msolPriceRatio: number): number;
+export declare function calculateEstimatedSuperStakeLiquidationPrice(lstDepositAmount: number, lstMaintenanceAssetWeight: number, solBorrowAmount: number, solMaintenanceLiabilityWeight: number, lstPriceRatio: number): number;

package/lib/math/superStake.js

@@ -3,17 +3,44 @@ 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.findBestSuperStakeIxs = void 0;
+exports.calculateEstimatedSuperStakeLiquidationPrice = exports.calculateSolEarned = exports.fetchJitoSolMetrics = exports.findBestJitoSolSuperStakeIxs = exports.findBestMSolSuperStakeIxs = exports.findBestSuperStakeIxs = 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"));
-async function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, marinadePrice, forceMarinade, onlyDirectRoutes, }) {
-    if (!marinadePrice) {
+const utils_1 = require("./utils");
+async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, }) {
+    if (marketIndex === 2) {
+        return findBestMSolSuperStakeIxs({
+            amount,
+            jupiterClient,
+            driftClient,
+            userAccountPublicKey,
+            price,
+            forceMarinade,
+            onlyDirectRoutes,
+        });
+    }
+    else if (marketIndex === 6) {
+        return findBestJitoSolSuperStakeIxs({
+            amount,
+            jupiterClient,
+            driftClient,
+            userAccountPublicKey,
+            onlyDirectRoutes,
+        });
+    }
+    else {
+        throw new Error(`Unsupported superstake market index: ${marketIndex}`);
+    }
+}
+exports.findBestSuperStakeIxs = findBestSuperStakeIxs;
+async function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, }) {
+    if (!price) {
         const marinadeProgram = (0, marinade_1.getMarinadeFinanceProgram)(driftClient.provider);
-        marinadePrice = await (0, marinade_1.getMarinadeMSolPrice)(marinadeProgram);
+        price = await (0, marinade_1.getMarinadeMSolPrice)(marinadeProgram);
     }
     const solMint = driftClient.getSpotMarketAccount(1).mint;
     const mSOLMint = driftClient.getSpotMarketAccount(2).mint;
@@ -32,7 +59,7 @@ async function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userA
     catch (e) {
         console.error('Error getting jupiter price', e);
     }
-    if (!jupiterPrice || marinadePrice <= jupiterPrice || forceMarinade) {
+    if (!jupiterPrice || price <= jupiterPrice || forceMarinade) {
         const ixs = await driftClient.getStakeForMSOLIx({
             amount,
             userAccountPublicKey,
@@ -41,7 +68,7 @@ async function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userA
             method: 'marinade',
             ixs,
             lookupTables: [],
-            price: marinadePrice,
+            price: price,
         };
     }
     else {
@@ -61,25 +88,137 @@ async function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userA
         };
     }
 }
-exports.findBestSuperStakeIxs = findBestSuperStakeIxs;
-async function calculateSolEarned({ user, depositRecords, }) {
+exports.findBestMSolSuperStakeIxs = findBestMSolSuperStakeIxs;
+async function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, }) {
+    const solMint = driftClient.getSpotMarketAccount(1).mint;
+    const JitoSolMint = driftClient.getSpotMarketAccount(6).mint;
+    let jupiterPrice;
+    let bestRoute;
+    try {
+        const jupiterRoutes = await jupiterClient.getRoutes({
+            inputMint: solMint,
+            outputMint: JitoSolMint,
+            amount,
+            onlyDirectRoutes,
+        });
+        bestRoute = jupiterRoutes[0];
+        jupiterPrice = bestRoute.inAmount / bestRoute.outAmount;
+    }
+    catch (e) {
+        console.error('Error getting jupiter price', e);
+        throw e;
+    }
+    const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
+        inMarketIndex: 1,
+        outMarketIndex: 6,
+        route: bestRoute,
+        jupiterClient,
+        amount,
+        userAccountPublicKey,
+    });
+    return {
+        method: 'jupiter',
+        ixs,
+        lookupTables,
+        price: jupiterPrice,
+    };
+}
+exports.findBestJitoSolSuperStakeIxs = findBestJitoSolSuperStakeIxs;
+const JITO_SOL_START_DATE = '2022-10-31T00:00:00Z';
+async function fetchJitoSolMetrics() {
+    const res = await (0, node_fetch_1.default)('https://kobe.mainnet.jito.network/', {
+        body: JSON.stringify({
+            operationName: 'QueryRoot',
+            variables: {
+                request: {
+                    bucketType: 'DAILY',
+                    rangeFilter: {
+                        start: JITO_SOL_START_DATE,
+                        end: new Date().toISOString(),
+                    },
+                    sortBy: {
+                        order: 'ASC',
+                        field: 'BLOCK_TIME',
+                    },
+                },
+            },
+            query: `
+						query QueryRoot($request: GetStakePoolStatsRequest!) {
+								getStakePoolStats(req: $request) {
+										tvl {
+												data
+												date
+										}
+										apy {
+												data
+												date
+										}
+										supply {
+												data
+												date
+										}
+								}
+						}
+				`,
+        }),
+        method: 'POST',
+    });
+    const data = await res.json();
+    return data;
+}
+exports.fetchJitoSolMetrics = fetchJitoSolMetrics;
+const getJitoSolHistoricalPriceMap = async (timestamps) => {
+    try {
+        const data = await fetchJitoSolMetrics();
+        const jitoSolHistoricalPriceMap = new Map();
+        const jitoSolHistoricalPriceInSol = [];
+        for (let i = 0; i < data.data.getStakePoolStats.supply.length; i++) {
+            const priceInSol = data.data.getStakePoolStats.tvl[i].data /
+                10 ** 9 /
+                data.data.getStakePoolStats.supply[i].data;
+            jitoSolHistoricalPriceInSol.push({
+                price: priceInSol,
+                ts: data.data.getStakePoolStats.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.map((r) => r.ts.toNumber()),
     ];
-    const msolRatios = new Map();
-    const getPrice = async (timestamp) => {
+    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();
-            msolRatios.set(timestamp, data);
+            lstRatios.set(timestamp, data);
         }
     };
-    await Promise.all(timestamps.map(getPrice));
+    if (marketIndex === 2) {
+        await Promise.all(timestamps.map(getMsolPrice));
+    }
+    else if (marketIndex === 6) {
+        lstRatios = await getJitoSolHistoricalPriceMap(timestamps);
+    }
     let solEarned = numericConstants_1.ZERO;
     for (const record of depositRecords) {
         if (record.marketIndex === 1) {
@@ -91,7 +230,7 @@ async function calculateSolEarned({ user, depositRecords, }) {
             }
         }
         else if (record.marketIndex === 2) {
-            const msolRatio = msolRatios.get(record.ts.toNumber());
+            const msolRatio = lstRatios.get(record.ts.toNumber());
             const msolRatioBN = new anchor_1.BN(msolRatio * web3_js_1.LAMPORTS_PER_SOL);
             const solAmount = record.amount.mul(msolRatioBN).div(numericConstants_1.LAMPORTS_PRECISION);
             if ((0, types_1.isVariant)(record.direction, 'deposit')) {
@@ -101,21 +240,34 @@ async function calculateSolEarned({ user, depositRecords, }) {
                 solEarned = solEarned.add(solAmount);
             }
         }
+        else if (record.marketIndex === 6) {
+            const jitoSolRatio = lstRatios.get(record.ts.toNumber());
+            const jitoSolRatioBN = new anchor_1.BN(jitoSolRatio * web3_js_1.LAMPORTS_PER_SOL);
+            const solAmount = record.amount
+                .mul(jitoSolRatioBN)
+                .div(numericConstants_1.LAMPORTS_PRECISION);
+            if ((0, types_1.isVariant)(record.direction, 'deposit')) {
+                solEarned = solEarned.sub(solAmount);
+            }
+            else {
+                solEarned = solEarned.add(solAmount);
+            }
+        }
     }
-    const currentMSOLTokenAmount = await user.getTokenAmount(2);
+    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);
-    const currentMSOLRatio = msolRatios.get(now);
-    const currentMSOLRatioBN = new anchor_1.BN(currentMSOLRatio * web3_js_1.LAMPORTS_PER_SOL);
-    solEarned = solEarned.add(currentMSOLTokenAmount.mul(currentMSOLRatioBN).div(numericConstants_1.LAMPORTS_PRECISION));
     solEarned = solEarned.add(currentSOLTokenAmount);
     return solEarned;
 }
 exports.calculateSolEarned = calculateSolEarned;
-// calculate estimated liquidation price (in mSOL/SOL) based on target amounts
-function calculateEstimatedSuperStakeLiquidationPrice(msolDepositAmount, msolMaintenanceAssetWeight, solBorrowAmount, solMaintenanceLiabilityWeight, msolPriceRatio) {
+// calculate estimated liquidation price (in LST/SOL) based on target amounts
+function calculateEstimatedSuperStakeLiquidationPrice(lstDepositAmount, lstMaintenanceAssetWeight, solBorrowAmount, solMaintenanceLiabilityWeight, lstPriceRatio) {
     const liquidationDivergence = (solMaintenanceLiabilityWeight * solBorrowAmount) /
-        (msolMaintenanceAssetWeight * msolDepositAmount * msolPriceRatio);
-    const liquidationPrice = msolPriceRatio * liquidationDivergence;
+        (lstMaintenanceAssetWeight * lstDepositAmount * lstPriceRatio);
+    const liquidationPrice = lstPriceRatio * liquidationDivergence;
     return liquidationPrice;
 }
 exports.calculateEstimatedSuperStakeLiquidationPrice = calculateEstimatedSuperStakeLiquidationPrice;

package/lib/math/trade.js

@@ -278,9 +278,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
         };
     }
     const takerIsLong = (0, types_2.isVariant)(direction, 'long');
-    const limitOrders = dlob[takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, takerIsLong
-        ? (0, market_1.calculateBidPrice)(market, oraclePriceData)
-        : (0, market_1.calculateAskPrice)(market, oraclePriceData));
+    const limitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData);
     const swapDirection = (0, amm_1.getSwapDirection)(assetType, direction);
     const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
     const amm = {
@@ -463,7 +461,7 @@ function calculateEstimatedSpotEntryPrice(assetType, amount, direction, market,
     }
     const basePrecision = new anchor_1.BN(Math.pow(10, market.decimals));
     const takerIsLong = (0, types_2.isVariant)(direction, 'long');
-    const dlobLimitOrders = dlob[takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'](market.marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
+    const dlobLimitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
     const serumLimitOrders = takerIsLong
         ? serumAsks.getL2(100)
         : serumBids.getL2(100);

package/lib/math/utils.d.ts

@@ -12,3 +12,4 @@ export declare const sigNum: (x: BN) => BN;
  * @returns: timeRemainingUntilUpdate (in seconds)
  */
 export declare function timeRemainingUntilUpdate(now: BN, lastUpdateTs: BN, updatePeriod: BN): BN;
+export declare const checkSameDate: (dateString1: string, dateString2: string) => boolean;

package/lib/math/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeRemainingUntilUpdate = exports.sigNum = exports.divCeil = exports.squareRootBN = exports.clampBN = void 0;
+exports.checkSameDate = exports.timeRemainingUntilUpdate = exports.sigNum = exports.divCeil = exports.squareRootBN = exports.clampBN = void 0;
 const __1 = require("../");
 function clampBN(x, min, max) {
     return __1.BN.max(min, __1.BN.min(x, max));
@@ -76,3 +76,12 @@ function timeRemainingUntilUpdate(now, lastUpdateTs, updatePeriod) {
     return timeRemainingUntilUpdate;
 }
 exports.timeRemainingUntilUpdate = timeRemainingUntilUpdate;
+const checkSameDate = (dateString1, dateString2) => {
+    const date1 = new Date(dateString1);
+    const date2 = new Date(dateString2);
+    const isSameDate = date1.getDate() === date2.getDate() &&
+        date1.getMonth() === date2.getMonth() &&
+        date1.getFullYear() === date2.getFullYear();
+    return isSameDate;
+};
+exports.checkSameDate = checkSameDate;

package/lib/orderSubscriber/OrderSubscriber.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { DriftClient } from '../driftClient';
 import { UserAccount } from '../types';
-import { Buffer } from 'buffer';
 import { DLOB } from '../dlob/DLOB';
 import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
 import { PollingSubscription } from './PollingSubscription';
@@ -22,7 +20,7 @@ export declare class OrderSubscriber {
     constructor(config: OrderSubscriberConfig);
     subscribe(): Promise<void>;
     fetch(): Promise<void>;
-    tryUpdateUserAccount(key: string, buffer: Buffer, slot: number): void;
+    tryUpdateUserAccount(key: string, userAccount: UserAccount, slot: number): void;
     getDLOB(slot: number): Promise<DLOB>;
     unsubscribe(): Promise<void>;
 }

package/lib/orderSubscriber/OrderSubscriber.js

@@ -22,6 +22,7 @@ class OrderSubscriber {
             this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
                 orderSubscriber: this,
                 skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+                resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
             });
         }
         this.eventEmitter = new events_1.EventEmitter();
@@ -57,7 +58,8 @@ class OrderSubscriber {
                 // @ts-ignore
                 const buffer = buffer_1.Buffer.from(programAccount.account.data[0], programAccount.account.data[1]);
                 programAccountSet.add(key);
-                this.tryUpdateUserAccount(key, buffer, slot);
+                const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
+                this.tryUpdateUserAccount(key, userAccount, slot);
             }
             for (const key of this.usersAccounts.keys()) {
                 if (!programAccountSet.has(key)) {
@@ -73,10 +75,9 @@ class OrderSubscriber {
             this.fetchPromise = undefined;
         }
     }
-    tryUpdateUserAccount(key, buffer, slot) {
+    tryUpdateUserAccount(key, userAccount, slot) {
         const slotAndUserAccount = this.usersAccounts.get(key);
         if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
-            const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
             const newOrders = userAccount.orders.filter((order) => {
                 var _a;
                 return order.slot.toNumber() > ((_a = slotAndUserAccount === null || slotAndUserAccount === void 0 ? void 0 : slotAndUserAccount.slot) !== null && _a !== void 0 ? _a : 0) &&

package/lib/orderSubscriber/WebsocketSubscription.d.ts

@@ -2,10 +2,12 @@ import { OrderSubscriber } from './OrderSubscriber';
 export declare class WebsocketSubscription {
     private orderSubscriber;
     private skipInitialLoad;
-    private websocketId;
-    constructor({ orderSubscriber, skipInitialLoad, }: {
+    private resubTimeoutMs?;
+    private subscriber;
+    constructor({ orderSubscriber, skipInitialLoad, resubTimeoutMs, }: {
         orderSubscriber: OrderSubscriber;
         skipInitialLoad?: boolean;
+        resubTimeoutMs?: number;
     });
     subscribe(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/orderSubscriber/WebsocketSubscription.js

@@ -2,29 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebsocketSubscription = void 0;
 const memcmp_1 = require("../memcmp");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
 class WebsocketSubscription {
-    constructor({ orderSubscriber, skipInitialLoad = false, }) {
+    constructor({ orderSubscriber, skipInitialLoad = false, resubTimeoutMs, }) {
         this.orderSubscriber = orderSubscriber;
         this.skipInitialLoad = skipInitialLoad;
+        this.resubTimeoutMs = resubTimeoutMs;
     }
     async subscribe() {
-        if (this.websocketId) {
-            return;
+        if (!this.subscriber) {
+            this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('OrderSubscriber', 'User', this.orderSubscriber.driftClient.program, this.orderSubscriber.driftClient.program.account.user.coder.accounts.decode.bind(this.orderSubscriber.driftClient.program.account.user.coder.accounts), {
+                filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getNonIdleUserFilter)()],
+                commitment: this.orderSubscriber.driftClient.opts.commitment,
+            }, this.resubTimeoutMs);
         }
-        this.websocketId =
-            this.orderSubscriber.driftClient.connection.onProgramAccountChange(this.orderSubscriber.driftClient.program.programId, (keyAccountInfo, context) => {
-                const userKey = keyAccountInfo.accountId.toBase58();
-                this.orderSubscriber.tryUpdateUserAccount(userKey, keyAccountInfo.accountInfo.data, context.slot);
-            }, this.orderSubscriber.driftClient.opts.commitment, [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getNonIdleUserFilter)()]);
+        await this.subscriber.subscribe((accountId, account, context) => {
+            const userKey = accountId.toBase58();
+            this.orderSubscriber.tryUpdateUserAccount(userKey, account, context.slot);
+        });
         if (!this.skipInitialLoad) {
             await this.orderSubscriber.fetch();
         }
     }
     async unsubscribe() {
-        if (this.websocketId) {
-            await this.orderSubscriber.driftClient.connection.removeProgramAccountChangeListener(this.websocketId);
-            this.websocketId = undefined;
-        }
+        if (!this.subscriber)
+            return;
+        this.subscriber.unsubscribe();
     }
 }
 exports.WebsocketSubscription = WebsocketSubscription;

package/lib/orderSubscriber/types.d.ts

@@ -9,6 +9,7 @@ export type OrderSubscriberConfig = {
     } | {
         type: 'websocket';
         skipInitialLoad?: boolean;
+        resubTimeoutMs?: number;
     };
 };
 export interface OrderSubscriberEvents {

package/lib/user.d.ts

@@ -180,14 +180,14 @@ export declare class User {
      * calculates current user leverage which is (total liability size) / (net asset value)
      * @returns : Precision TEN_THOUSAND
      */
-    getLeverage(): BN;
+    getLeverage(includeOpenOrders?: boolean): BN;
     calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }: {
         perpLiabilityValue: BN;
         perpPnl: BN;
         spotAssetValue: BN;
         spotLiabilityValue: BN;
     }): BN;
-    getLeverageComponents(): {
+    getLeverageComponents(includeOpenOrders?: boolean): {
         perpLiabilityValue: BN;
         perpPnl: BN;
         spotAssetValue: BN;

package/lib/user.js

@@ -822,8 +822,8 @@ class User {
      * calculates current user leverage which is (total liability size) / (net asset value)
      * @returns : Precision TEN_THOUSAND
      */
-    getLeverage() {
-        return this.calculateLeverageFromComponents(this.getLeverageComponents());
+    getLeverage(includeOpenOrders = true) {
+        return this.calculateLeverageFromComponents(this.getLeverageComponents(includeOpenOrders));
     }
     calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }) {
         const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
@@ -834,10 +834,10 @@ class User {
         }
         return totalLiabilityValue.mul(numericConstants_1.TEN_THOUSAND).div(netAssetValue);
     }
-    getLeverageComponents() {
-        const perpLiability = this.getTotalPerpPositionValue(undefined, undefined, true);
+    getLeverageComponents(includeOpenOrders = true) {
+        const perpLiability = this.getTotalPerpPositionValue(undefined, undefined, includeOpenOrders);
         const perpPnl = this.getUnrealizedPNL(true);
-        const { totalAssetValue: spotAssetValue, totalLiabilityValue: spotLiabilityValue, } = this.getSpotMarketAssetAndLiabilityValue(undefined, undefined, undefined, true);
+        const { totalAssetValue: spotAssetValue, totalLiabilityValue: spotLiabilityValue, } = this.getSpotMarketAssetAndLiabilityValue(undefined, undefined, undefined, includeOpenOrders);
         return {
             perpLiabilityValue: perpLiability,
             perpPnl,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.41.0-beta.0",
+	"version": "2.41.0-beta.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -44,6 +44,7 @@
 		"uuid": "^8.3.2"
 	},
 	"devDependencies": {
+		"@types/big.js": "^6.2.0",
 		"@types/chai": "^4.3.1",
 		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",