@drift-labs/sdk 2.31.1-beta.9 → 2.32.1-beta.0

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/utils.d.ts

@@ -2,6 +2,7 @@ import { BN } from '../';
 export declare function clampBN(x: BN, min: BN, max: BN): BN;
 export declare const squareRootBN: (n: BN) => BN;
 export declare const divCeil: (a: BN, b: BN) => BN;
+export declare const sigNum: (x: BN) => BN;
 /**
  * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
  * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates

package/lib/math/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeRemainingUntilUpdate = exports.divCeil = exports.squareRootBN = exports.clampBN = void 0;
+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));
@@ -34,6 +34,10 @@ const divCeil = (a, b) => {
     }
 };
 exports.divCeil = divCeil;
+const sigNum = (x) => {
+    return x.isNeg() ? new __1.BN(-1) : new __1.BN(1);
+};
+exports.sigNum = sigNum;
 /**
  * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
  * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates

package/lib/orderParams.d.ts

@@ -1,15 +1,28 @@
-import { OptionalOrderParams, OrderTriggerCondition } from './types';
+import { OptionalOrderParams, OrderParams, OrderTriggerCondition } from './types';
 import { BN } from '@coral-xyz/anchor';
-export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
     price: BN;
 }): OptionalOrderParams;
-export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
     triggerCondition: OrderTriggerCondition;
     triggerPrice: BN;
 }): OptionalOrderParams;
-export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
     triggerCondition: OrderTriggerCondition;
     triggerPrice: BN;
     price: BN;
 }): OptionalOrderParams;
-export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'>): OptionalOrderParams;
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */
+export declare function getOrderParams(optionalOrderParams: OptionalOrderParams, overridingParams?: Record<string, any>): OrderParams;

package/lib/orderParams.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+exports.getOrderParams = exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
 function getLimitOrderParams(params) {
     return Object.assign({}, params, {
@@ -26,3 +26,19 @@ function getMarketOrderParams(params) {
     });
 }
 exports.getMarketOrderParams = getMarketOrderParams;
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */
+function getOrderParams(optionalOrderParams, overridingParams = {}) {
+    return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams, overridingParams);
+}
+exports.getOrderParams = getOrderParams;

package/lib/user.d.ts

@@ -42,6 +42,7 @@ export declare class User {
      * @returns userSpotPosition
      */
     getSpotPosition(marketIndex: number): SpotPosition | undefined;
+    getEmptySpotPosition(marketIndex: number): SpotPosition;
     /**
      * Returns the token amount for a given market. The spot market precision is based on the token mint decimals.
      * Positive if it is a deposit, negative if it is a borrow.
@@ -126,7 +127,6 @@ export declare class User {
     getSpotLiabilityValue(tokenAmount: BN, oraclePriceData: OraclePriceData, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory, liquidationBuffer?: BN, strict?: boolean, now?: BN): BN;
     getSpotMarketAssetValue(marketIndex?: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
     getSpotAssetValue(tokenAmount: BN, oraclePriceData: OraclePriceData, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory, strict?: boolean, now?: BN): BN;
-    getSpotTokenAmount(marketIndex: number): BN;
     getSpotPositionValue(marketIndex: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
     getNetSpotMarketValue(withWeightMarginCategory?: MarginCategory): BN;
     /**
@@ -160,6 +160,12 @@ export declare class User {
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage(): BN;
+    calculateLeverageFromComponents({ perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue, }: {
+        perpLiabilityValue: BN;
+        perpPnl: BN;
+        spotAssetValue: BN;
+        spotLiabilityValue: BN;
+    }): BN;
     getLeverageComponents(): {
         perpLiabilityValue: BN;
         perpPnl: BN;
@@ -252,6 +258,44 @@ export declare class User {
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
     getMaxTradeSizeUSDCForSpot(targetMarketIndex: number, direction: PositionDirection, currentQuoteAssetValue?: BN, currentSpotMarketNetValue?: BN): BN;
+    /**
+     * Calculates the max amount of token that can be swapped from inMarket to outMarket
+     * Assumes swap happens at oracle price
+     *
+     * @param inMarketIndex
+     * @param outMarketIndex
+     * @param calculateSwap function to similate in to out swa
+     * @param iterationLimit how long to run appromixation before erroring out
+     */
+    getMaxSwapAmount({ inMarketIndex, outMarketIndex, calculateSwap, iterationLimit, }: {
+        inMarketIndex: number;
+        outMarketIndex: number;
+        calculateSwap?: (inAmount: BN) => BN;
+        iterationLimit?: number;
+    }): {
+        inAmount: BN;
+        outAmount: BN;
+        leverage: BN;
+    };
+    cloneAndUpdateSpotPosition(position: SpotPosition, tokenAmount: BN, market: SpotMarketAccount): SpotPosition;
+    calculateSpotPositionFreeCollateralContribution(spotPosition: SpotPosition): BN;
+    calculateSpotPositionLeverageContribution(spotPosition: SpotPosition): {
+        totalAssetValue: BN;
+        totalLiabilityValue: BN;
+    };
+    /**
+     * Estimates what the user leverage will be after swap
+     * @param inMarketIndex
+     * @param outMarketIndex
+     * @param inAmount
+     * @param outAmount
+     */
+    accountLeverageAfterSwap({ inMarketIndex, outMarketIndex, inAmount, outAmount, }: {
+        inMarketIndex: number;
+        outMarketIndex: number;
+        inAmount: BN;
+        outAmount: BN;
+    }): BN;
     /**
      * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
      * @param targetMarketIndex