@drift-labs/sdk 2.31.1-beta.2 → 2.31.1-beta.21

package/lib/math/spotBalance.d.ts

@@ -49,8 +49,15 @@ export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: numbe
 export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData): BN;
 export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
 export declare function calculateLiabilityWeight(size: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
-export declare function calculateUtilization(bank: SpotMarketAccount): BN;
-export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
+export declare function calculateUtilization(bank: SpotMarketAccount, delta?: any): BN;
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+export declare function calculateSpotMarketBorrowCapacity(spotMarketAccount: SpotMarketAccount, targetBorrowRate: BN): BN;
+export declare function calculateInterestRate(bank: SpotMarketAccount, delta?: any): BN;
 export declare function calculateDepositRate(bank: SpotMarketAccount): BN;
 export declare function calculateBorrowRate(bank: SpotMarketAccount): BN;
 export declare function calculateInterestAccumulated(bank: SpotMarketAccount, now: BN): {

package/lib/math/spotBalance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
@@ -156,9 +156,15 @@ function calculateLiabilityWeight(size, spotMarket, marginCategory) {
     return liabilityWeight;
 }
 exports.calculateLiabilityWeight = calculateLiabilityWeight;
-function calculateUtilization(bank) {
-    const tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
-    const tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+function calculateUtilization(bank, delta = numericConstants_1.ZERO) {
+    let tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
+    let tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+    if (delta.gt(numericConstants_1.ZERO)) {
+        tokenDepositAmount = tokenDepositAmount.add(delta);
+    }
+    else if (delta.lt(numericConstants_1.ZERO)) {
+        tokenBorrowAmount = tokenBorrowAmount.add(delta.abs());
+    }
     let utilization;
     if (tokenBorrowAmount.eq(numericConstants_1.ZERO) && tokenDepositAmount.eq(numericConstants_1.ZERO)) {
         utilization = numericConstants_1.ZERO;
@@ -174,8 +180,50 @@ function calculateUtilization(bank) {
     return utilization;
 }
 exports.calculateUtilization = calculateUtilization;
-function calculateInterestRate(bank) {
-    const utilization = calculateUtilization(bank);
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+function calculateSpotMarketBorrowCapacity(spotMarketAccount, targetBorrowRate) {
+    const currentBorrowRate = calculateBorrowRate(spotMarketAccount);
+    if (currentBorrowRate.gte(targetBorrowRate)) {
+        return numericConstants_1.ZERO;
+    }
+    else {
+        const tokenDepositAmount = getTokenAmount(spotMarketAccount.depositBalance, spotMarketAccount, types_1.SpotBalanceType.DEPOSIT);
+        const tokenBorrowAmount = getTokenAmount(spotMarketAccount.borrowBalance, spotMarketAccount, types_1.SpotBalanceType.BORROW);
+        let targetUtilization;
+        // target utilization past mid point
+        if (targetBorrowRate.gte(new anchor_1.BN(spotMarketAccount.optimalBorrowRate))) {
+            const borrowRateSlope = new anchor_1.BN(spotMarketAccount.maxBorrowRate - spotMarketAccount.optimalBorrowRate)
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(spotMarketAccount.optimalUtilization)));
+            const surplusTargetUtilization = targetBorrowRate
+                .sub(new anchor_1.BN(spotMarketAccount.optimalBorrowRate))
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(borrowRateSlope);
+            targetUtilization = surplusTargetUtilization.add(new anchor_1.BN(spotMarketAccount.optimalUtilization));
+        }
+        else {
+            const borrowRateSlope = new anchor_1.BN(spotMarketAccount.optimalBorrowRate)
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(new anchor_1.BN(spotMarketAccount.optimalUtilization));
+            targetUtilization = targetBorrowRate
+                .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+                .div(borrowRateSlope);
+        }
+        const targetBorrowAmount = tokenDepositAmount
+            .mul(targetUtilization)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+        const capacity = anchor_1.BN.max(numericConstants_1.ZERO, targetBorrowAmount.sub(tokenBorrowAmount));
+        return capacity;
+    }
+}
+exports.calculateSpotMarketBorrowCapacity = calculateSpotMarketBorrowCapacity;
+function calculateInterestRate(bank, delta = numericConstants_1.ZERO) {
+    const utilization = calculateUtilization(bank, delta);
     let interestRate;
     if (utilization.gt(new anchor_1.BN(bank.optimalUtilization))) {
         const surplusUtilization = utilization.sub(new anchor_1.BN(bank.optimalUtilization));

package/lib/math/superStake.d.ts

@@ -0,0 +1,22 @@
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { JupiterClient } from '../jupiter/jupiterClient';
+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, }: {
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    userAccountPublicKey?: PublicKey;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price: number;
+}>;
+export declare function calculateSolEarned({ user, depositRecords, }: {
+    user: User;
+    depositRecords: DepositRecord[];
+}): Promise<BN>;
+export declare function calculateEstimatedSuperStakeLiquidationPrice(msolDepositAmount: number, msolMaintenanceAssetWeight: number, solBorrowAmount: number, solMaintenanceLiabilityWeight: number, msolPriceRatio: number): number;

package/lib/math/superStake.js

@@ -0,0 +1,108 @@
+"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.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, }) {
+    const marinadeProgram = (0, marinade_1.getMarinadeFinanceProgram)(driftClient.provider);
+    const marinadePrice = await (0, marinade_1.getMarinadeMSolPrice)(marinadeProgram);
+    const solMint = driftClient.getSpotMarketAccount(1).mint;
+    const mSOLMint = driftClient.getSpotMarketAccount(2).mint;
+    const jupiterRoutes = await jupiterClient.getRoutes({
+        inputMint: solMint,
+        outputMint: mSOLMint,
+        amount,
+    });
+    const bestRoute = jupiterRoutes[0];
+    const jupiterPrice = bestRoute.inAmount / bestRoute.outAmount;
+    if (marinadePrice <= jupiterPrice) {
+        const ixs = await driftClient.getStakeForMSOLIx({ amount });
+        return {
+            method: 'marinade',
+            ixs,
+            lookupTables: [],
+            price: marinadePrice,
+        };
+    }
+    else {
+        const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
+            inMarketIndex: 1,
+            outMarketIndex: 2,
+            route: bestRoute,
+            jupiterClient,
+            amount,
+            userAccountPublicKey,
+        });
+        return {
+            method: 'jupiter',
+            ixs,
+            lookupTables,
+            price: jupiterPrice,
+        };
+    }
+}
+exports.findBestSuperStakeIxs = findBestSuperStakeIxs;
+async function calculateSolEarned({ user, depositRecords, }) {
+    const now = Date.now() / 1000;
+    const timestamps = [
+        now,
+        ...depositRecords.map((r) => r.ts.toNumber()),
+    ];
+    const msolRatios = new Map();
+    const getPrice = async (timestamp) => {
+        const date = new Date(timestamp * 1000); // Convert Unix timestamp to milliseconds
+        const swaggerApiDateTime = date.toISOString(); // Format date as swagger API date-time
+        const url = `https://api.marinade.finance/msol/price_sol?time=${swaggerApiDateTime}`;
+        const response = await (0, node_fetch_1.default)(url);
+        if (response.status === 200) {
+            const data = await response.json();
+            msolRatios.set(timestamp, data);
+        }
+    };
+    await Promise.all(timestamps.map(getPrice));
+    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) {
+            const msolRatio = msolRatios.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')) {
+                solEarned = solEarned.sub(solAmount);
+            }
+            else {
+                solEarned = solEarned.add(solAmount);
+            }
+        }
+    }
+    const currentMSOLTokenAmount = await user.getTokenAmount(2);
+    const currentSOLTokenAmount = await user.getTokenAmount(1);
+    const currentMSOLRatio = msolRatios.get(now);
+    const currentMSOLRatioBN = new 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) {
+    const liquidationDivergence = (solMaintenanceLiabilityWeight * solBorrowAmount) /
+        (msolMaintenanceAssetWeight * msolDepositAmount * msolPriceRatio);
+    const liquidationPrice = msolPriceRatio * liquidationDivergence;
+    return liquidationPrice;
+}
+exports.calculateEstimatedSuperStakeLiquidationPrice = calculateEstimatedSuperStakeLiquidationPrice;

package/lib/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;

package/lib/math/tiers.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perpTierIsAsSafeAs = exports.getSpotMarketTierNumber = exports.getPerpMarketTierNumber = void 0;
+const types_1 = require("../types");
+function getPerpMarketTierNumber(perpMarket) {
+    if ((0, types_1.isVariant)(perpMarket.contractTier, 'a')) {
+        return 0;
+    }
+    else if ((0, types_1.isVariant)(perpMarket.contractTier, 'b')) {
+        return 1;
+    }
+    else if ((0, types_1.isVariant)(perpMarket.contractTier, 'c')) {
+        return 2;
+    }
+    else if ((0, types_1.isVariant)(perpMarket.contractTier, 'speculative')) {
+        return 3;
+    }
+    else if ((0, types_1.isVariant)(perpMarket.contractTier, 'isolated')) {
+        return 4;
+    }
+    else {
+        return 5;
+    }
+}
+exports.getPerpMarketTierNumber = getPerpMarketTierNumber;
+function getSpotMarketTierNumber(spotMarket) {
+    if ((0, types_1.isVariant)(spotMarket.assetTier, 'collateral')) {
+        return 0;
+    }
+    else if ((0, types_1.isVariant)(spotMarket.assetTier, 'protected')) {
+        return 1;
+    }
+    else if ((0, types_1.isVariant)(spotMarket.assetTier, 'cross')) {
+        return 2;
+    }
+    else if ((0, types_1.isVariant)(spotMarket.assetTier, 'isolated')) {
+        return 3;
+    }
+    else if ((0, types_1.isVariant)(spotMarket.assetTier, 'unlisted')) {
+        return 4;
+    }
+    else {
+        return 5;
+    }
+}
+exports.getSpotMarketTierNumber = getSpotMarketTierNumber;
+function perpTierIsAsSafeAs(perpTier, otherPerpTier, otherSpotTier) {
+    const asSafeAsPerp = perpTier <= otherPerpTier;
+    const asSafeAsSpot = otherSpotTier === 4 || (otherSpotTier >= 2 && perpTier <= 2);
+    return asSafeAsSpot && asSafeAsPerp;
+}
+exports.perpTierIsAsSafeAs = perpTierIsAsSafeAs;

package/lib/tx/retryTxSender.d.ts

@@ -1,17 +1,26 @@
 /// <reference types="node" />
 import { TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount } from '@solana/web3.js';
-import { AnchorProvider } from '@coral-xyz/anchor';
+import { IWallet } from '../types';
 type ResolveReference = {
     resolve?: () => void;
 };
 export declare class RetryTxSender implements TxSender {
-    provider: AnchorProvider;
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
     timeout: number;
     retrySleep: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
+    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        retrySleep?: number;
+        additionalConnections?: any;
+    });
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;

package/lib/tx/retryTxSender.js

@@ -5,16 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryTxSender = void 0;
 const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
 const assert_1 = __importDefault(require("assert"));
 const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
 class RetryTxSender {
-    constructor(provider, timeout, retrySleep, additionalConnections = new Array()) {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), }) {
         this.timoutCount = 0;
-        this.provider = provider;
-        this.timeout = timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT;
-        this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.retrySleep = retrySleep;
         this.additionalConnections = additionalConnections;
     }
     async send(tx, additionalSigners, opts, preSigned) {
@@ -22,7 +25,7 @@ class RetryTxSender {
             additionalSigners = [];
         }
         if (opts === undefined) {
-            opts = this.provider.opts;
+            opts = this.opts;
         }
         const signedTx = preSigned
             ? tx
@@ -30,14 +33,14 @@ class RetryTxSender {
         return this.sendRawTransaction(signedTx.serialize(), opts);
     }
     async prepareTx(tx, additionalSigners, opts) {
-        tx.feePayer = this.provider.wallet.publicKey;
-        tx.recentBlockhash = (await this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
+        tx.feePayer = this.wallet.publicKey;
+        tx.recentBlockhash = (await this.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
         additionalSigners
             .filter((s) => s !== undefined)
             .forEach((kp) => {
             tx.partialSign(kp);
         });
-        const signedTx = await this.provider.wallet.signTransaction(tx);
+        const signedTx = await this.wallet.signTransaction(tx);
         return signedTx;
     }
     async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts) {
@@ -45,11 +48,11 @@ class RetryTxSender {
             additionalSigners = [];
         }
         if (opts === undefined) {
-            opts = this.provider.opts;
+            opts = this.opts;
         }
         const message = new web3_js_1.TransactionMessage({
-            payerKey: this.provider.wallet.publicKey,
-            recentBlockhash: (await this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash,
+            payerKey: this.wallet.publicKey,
+            recentBlockhash: (await this.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash,
             instructions: ixs,
         }).compileToV0Message(lookupTableAccounts);
         const tx = new web3_js_1.VersionedTransaction(message);
@@ -61,9 +64,9 @@ class RetryTxSender {
             signedTx = tx;
             // @ts-ignore
         }
-        else if (this.provider.wallet.payer) {
+        else if (this.wallet.payer) {
             // @ts-ignore
-            tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.provider.wallet.payer));
+            tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.wallet.payer));
             signedTx = tx;
         }
         else {
@@ -71,10 +74,10 @@ class RetryTxSender {
                 tx.sign([kp]);
             });
             // @ts-ignore
-            signedTx = await this.provider.wallet.signTransaction(tx);
+            signedTx = await this.wallet.signTransaction(tx);
         }
         if (opts === undefined) {
-            opts = this.provider.opts;
+            opts = this.opts;
         }
         return this.sendRawTransaction(signedTx.serialize(), opts);
     }
@@ -82,7 +85,7 @@ class RetryTxSender {
         const startTime = this.getTimestamp();
         let txid;
         try {
-            txid = await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+            txid = await this.connection.sendRawTransaction(rawTransaction, opts);
             this.sendToAdditionalConnections(rawTransaction, opts);
         }
         catch (e) {
@@ -103,7 +106,7 @@ class RetryTxSender {
             while (!done && this.getTimestamp() - startTime < this.timeout) {
                 await this.sleep(resolveReference);
                 if (!done) {
-                    this.provider.connection
+                    this.connection
                         .sendRawTransaction(rawTransaction, opts)
                         .catch((e) => {
                         console.error(e);
@@ -137,12 +140,9 @@ class RetryTxSender {
         }
         (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
         const start = Date.now();
-        const subscriptionCommitment = commitment || this.provider.opts.commitment;
+        const subscriptionCommitment = commitment || this.opts.commitment;
         const subscriptionIds = new Array();
-        const connections = [
-            this.provider.connection,
-            ...this.additionalConnections,
-        ];
+        const connections = [this.connection, ...this.additionalConnections];
         let response = null;
         const promises = connections.map((connection, i) => {
             let subscriptionId;

package/lib/tx/types.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="node" />
-import { Provider } from '@coral-xyz/anchor';
 import { AddressLookupTableAccount, ConfirmOptions, Signer, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
+import { IWallet } from '../types';
 export type TxSigAndSlot = {
     txSig: TransactionSignature;
     slot: number;
 };
 export interface TxSender {
-    provider: Provider;
+    wallet: IWallet;
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;

package/lib/user.d.ts

@@ -107,6 +107,7 @@ export declare class User {
      */
     getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN;
     getActivePerpPositions(): PerpPosition[];
+    getActiveSpotPositions(): SpotPosition[];
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
@@ -185,7 +186,11 @@ export declare class User {
      * @returns : Precision TEN_THOUSAND
      */
     getMarginRatio(): BN;
-    canBeLiquidated(): boolean;
+    canBeLiquidated(): {
+        canBeLiquidated: boolean;
+        marginRequirement: BN;
+        totalCollateral: BN;
+    };
     isBeingLiquidated(): boolean;
     isBankrupt(): boolean;
     /**
@@ -277,6 +282,10 @@ export declare class User {
         maxDepositAmount: BN;
     };
     canMakeIdle(slot: BN, slotsBeforeIdle: BN): boolean;
+    getSafestTiers(): {
+        perpTier: number;
+        spotTier: number;
+    };
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore

package/lib/user.js

@@ -12,6 +12,7 @@ const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSub
 const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
 const spotPosition_1 = require("./math/spotPosition");
 const oracles_1 = require("./math/oracles");
+const tiers_1 = require("./math/tiers");
 class User {
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -20,13 +21,16 @@ class User {
         this._isSubscribed = val;
     }
     constructor(config) {
-        var _a;
+        var _a, _b;
         this._isSubscribed = false;
         this.driftClient = config.driftClient;
         this.userAccountPublicKey = config.userAccountPublicKey;
         if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
             this.accountSubscriber = new pollingUserAccountSubscriber_1.PollingUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey, config.accountSubscription.accountLoader);
         }
+        else if (((_b = config.accountSubscription) === null || _b === void 0 ? void 0 : _b.type) === 'custom') {
+            this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
+        }
         else {
             this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.driftClient.program, config.userAccountPublicKey);
         }
@@ -176,7 +180,9 @@ class User {
      * @returns : pnl from settle
      */
     getPerpPositionWithLPSettle(marketIndex, originalPosition) {
-        originalPosition = originalPosition !== null && originalPosition !== void 0 ? originalPosition : this.getPerpPosition(marketIndex);
+        var _a;
+        originalPosition =
+            (_a = originalPosition !== null && originalPosition !== void 0 ? originalPosition : this.getPerpPosition(marketIndex)) !== null && _a !== void 0 ? _a : this.getEmptyPosition(marketIndex);
         if (originalPosition.lpShares.eq(numericConstants_1.ZERO)) {
             return [originalPosition, numericConstants_1.ZERO, numericConstants_1.ZERO];
         }
@@ -228,7 +234,7 @@ class User {
         let pnl;
         if (updateType == 'open' || updateType == 'increase') {
             newQuoteEntry = position.quoteEntryAmount.add(deltaQaa);
-            pnl = 0;
+            pnl = numericConstants_1.ZERO;
         }
         else if (updateType == 'reduce' || updateType == 'close') {
             newQuoteEntry = position.quoteEntryAmount.sub(position.quoteEntryAmount
@@ -305,6 +311,9 @@ class User {
             !(pos.openOrders == 0) ||
             !pos.lpShares.eq(numericConstants_1.ZERO));
     }
+    getActiveSpotPositions() {
+        return this.getUserAccount().spotPositions.filter((pos) => !(0, spotPosition_1.isSpotPositionAvailable)(pos));
+    }
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
@@ -601,7 +610,8 @@ class User {
      * @returns : Precision QUOTE_PRECISION
      */
     getPerpPositionValue(marketIndex, oraclePriceData, includeOpenOrders = false) {
-        const userPosition = this.getPerpPosition(marketIndex) || this.getEmptyPosition(marketIndex);
+        const userPosition = this.getPerpPositionWithLPSettle(marketIndex)[0] ||
+            this.getEmptyPosition(marketIndex);
         const market = this.driftClient.getPerpMarketAccount(userPosition.marketIndex);
         return (0, margin_1.calculateBaseAssetValueWithOracle)(market, userPosition, oraclePriceData, includeOpenOrders);
     }
@@ -775,12 +785,16 @@ class User {
         const totalCollateral = this.getTotalCollateral('Maintenance');
         // if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
         let liquidationBuffer = undefined;
-        const isBeingLiquidated = (0, types_1.isVariant)(this.getUserAccount().status, 'beingLiquidated');
-        if (isBeingLiquidated) {
+        if (this.isBeingLiquidated()) {
             liquidationBuffer = new _1.BN(this.driftClient.getStateAccount().liquidationMarginBufferRatio);
         }
-        const maintenanceRequirement = this.getMaintenanceMarginRequirement(liquidationBuffer);
-        return totalCollateral.lt(maintenanceRequirement);
+        const marginRequirement = this.getMaintenanceMarginRequirement(liquidationBuffer);
+        const canBeLiquidated = totalCollateral.lt(marginRequirement);
+        return {
+            canBeLiquidated,
+            marginRequirement,
+            totalCollateral,
+        };
     }
     isBeingLiquidated() {
         return (0, types_1.isOneOfVariant)(this.getUserAccount().status, [
@@ -1281,6 +1295,23 @@ class User {
         }
         return true;
     }
+    getSafestTiers() {
+        let safestPerpTier = 4;
+        let safestSpotTier = 4;
+        for (const perpPosition of this.getActivePerpPositions()) {
+            safestPerpTier = Math.min(safestPerpTier, (0, tiers_1.getPerpMarketTierNumber)(this.driftClient.getPerpMarketAccount(perpPosition.marketIndex)));
+        }
+        for (const spotPosition of this.getActiveSpotPositions()) {
+            if ((0, types_1.isVariant)(spotPosition.balanceType, 'deposit')) {
+                continue;
+            }
+            safestSpotTier = Math.min(safestSpotTier, (0, tiers_1.getSpotMarketTierNumber)(this.driftClient.getSpotMarketAccount(spotPosition.marketIndex)));
+        }
+        return {
+            perpTier: safestPerpTier,
+            spotTier: safestSpotTier,
+        };
+    }
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore

package/lib/userConfig.d.ts

@@ -1,6 +1,7 @@
 import { DriftClient } from './driftClient';
 import { PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { UserAccountSubscriber } from './accounts/types';
 export type UserConfig = {
     accountSubscription?: UserSubscriptionConfig;
     driftClient: DriftClient;
@@ -11,4 +12,7 @@ export type UserSubscriptionConfig = {
 } | {
     type: 'polling';
     accountLoader: BulkAccountLoader;
+} | {
+    type: 'custom';
+    userAccountSubscriber: UserAccountSubscriber;
 };

package/lib/userStats.js

@@ -7,12 +7,15 @@ const webSocketUserStatsAccountSubsriber_1 = require("./accounts/webSocketUserSt
 const pda_1 = require("./addresses/pda");
 class UserStats {
     constructor(config) {
-        var _a;
+        var _a, _b;
         this.driftClient = config.driftClient;
         this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
         if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
             this.accountSubscriber = new pollingUserStatsAccountSubscriber_1.PollingUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, config.accountSubscription.accountLoader);
         }
+        else if (((_b = config.accountSubscription) === null || _b === void 0 ? void 0 : _b.type) === 'custom') {
+            throw new Error('Custom account subscription not yet implemented for user stats');
+        }
         else {
             this.accountSubscriber = new webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey);
         }

package/lib/userStatsConfig.d.ts

@@ -11,4 +11,6 @@ export type UserStatsSubscriptionConfig = {
 } | {
     type: 'polling';
     accountLoader: BulkAccountLoader;
+} | {
+    type: 'custom';
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.31.1-beta.2",
+	"version": "2.31.1-beta.21",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",