@drift-labs/sdk 2.15.0 → 2.16.0-beta.2

package/lib/driftClient.js

@@ -366,11 +366,16 @@ class DriftClient {
     }
     async updateUserMarginTradingEnabled(marginTradingEnabled, subAccountId = 0) {
         const userAccountPublicKey = pda_1.getUserAccountPublicKeySync(this.program.programId, this.wallet.publicKey, subAccountId);
+        await this.addUser(subAccountId);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(subAccountId)],
+        });
         const tx = await this.program.transaction.updateUserMarginTradingEnabled(subAccountId, marginTradingEnabled, {
             accounts: {
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
+            remainingAccounts,
         });
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;

package/lib/events/fetchLogs.js

@@ -20,11 +20,11 @@ async function fetchLogs(connection, programId, finality, beforeTx, untilTx, lim
         return undefined;
     }
     const chunkedSignatures = chunk(filteredSignatures, 100);
+    const config = { commitment: finality, maxSupportedTransactionVersion: 0 };
     const transactionLogs = (await Promise.all(chunkedSignatures.map(async (chunk) => {
-        const transactions = await connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), {
-            commitment: finality,
-            maxSupportedTransactionVersion: 0,
-        });
+        const transactions = await connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), 
+        //@ts-ignore
+        config);
         return transactions.reduce((logs, transaction) => {
             if (transaction) {
                 logs.push(mapTransactionResponseToLog(transaction));

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.15.0",
+    "version": "2.16.0-beta.2",
     "name": "drift",
     "instructions": [
         {
@@ -8569,6 +8569,11 @@
             "code": 6225,
             "name": "InvalidOracleForSettlePnl",
             "msg": "InvalidOracleForSettlePnl"
+        },
+        {
+            "code": 6226,
+            "name": "MarginOrdersOpen",
+            "msg": "MarginOrdersOpen"
         }
     ]
 }

package/lib/math/margin.js

@@ -12,9 +12,7 @@ imfFactor, liabilityWeight, precision) {
         return liabilityWeight;
     }
     const sizeSqrt = utils_1.squareRootBN(size.abs().mul(new anchor_1.BN(10)).add(new anchor_1.BN(1))); //1e9 -> 1e10 -> 1e5
-    const denom0 = anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor));
-    assert_1.assert(denom0.gt(numericConstants_1.ZERO));
-    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor))));
+    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(new anchor_1.BN(5)));
     const denom = new anchor_1.BN(100000).mul(numericConstants_1.SPOT_MARKET_IMF_PRECISION).div(precision);
     assert_1.assert(denom.gt(numericConstants_1.ZERO));
     const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(sizeSqrt // 1e5

package/lib/math/market.js

@@ -63,12 +63,14 @@ exports.calculateOracleSpread = calculateOracleSpread;
 function calculateMarketMarginRatio(market, size, marginCategory) {
     let marginRatio;
     switch (marginCategory) {
-        case 'Initial':
+        case 'Initial': {
             marginRatio = margin_1.calculateSizePremiumLiabilityWeight(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
-        case 'Maintenance':
+        }
+        case 'Maintenance': {
             marginRatio = margin_1.calculateSizePremiumLiabilityWeight(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioMaintenance), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
+        }
     }
     return marginRatio;
 }

package/lib/math/spotBalance.d.ts

@@ -8,7 +8,7 @@ export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotB
 export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData, oraclePriceTwap: BN): BN;
 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(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 calculateDepositRate(bank: SpotMarketAccount): BN;

package/lib/math/spotBalance.js

@@ -84,30 +84,30 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
     return assetWeight;
 }
 exports.calculateAssetWeight = calculateAssetWeight;
-function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
+function calculateLiabilityWeight(size, spotMarket, marginCategory) {
     const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
     let sizeInAmmReservePrecision;
     if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
-        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+        sizeInAmmReservePrecision = size.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
     }
     else {
-        sizeInAmmReservePrecision = balanceAmount
+        sizeInAmmReservePrecision = size
             .mul(numericConstants_1.AMM_RESERVE_PRECISION)
             .div(sizePrecision);
     }
-    let assetWeight;
+    let liabilityWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            liabilityWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         case 'Maintenance':
-            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            liabilityWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
-            assetWeight = spotMarket.initialLiabilityWeight;
+            liabilityWeight = spotMarket.initialLiabilityWeight;
             break;
     }
-    return assetWeight;
+    return liabilityWeight;
 }
 exports.calculateLiabilityWeight = calculateLiabilityWeight;
 function calculateUtilization(bank) {

package/lib/math/spotMarket.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { SpotMarketAccount } from '../types';
+import { MarginCategory, SpotBalanceType, SpotMarketAccount } from '../types';
 export declare function castNumberToSpotPrecision(value: number, spotMarket: SpotMarketAccount): BN;
+export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType): number;

package/lib/math/spotMarket.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.castNumberToSpotPrecision = void 0;
+exports.calculateSpotMarketMarginRatio = exports.castNumberToSpotPrecision = void 0;
 const anchor_1 = require("@project-serum/anchor");
+const types_1 = require("../types");
+const spotBalance_1 = require("./spotBalance");
+const numericConstants_1 = require("../constants/numericConstants");
 function castNumberToSpotPrecision(value, spotMarket) {
     return new anchor_1.BN(value * Math.pow(10, spotMarket.decimals));
 }
 exports.castNumberToSpotPrecision = castNumberToSpotPrecision;
+function calculateSpotMarketMarginRatio(market, marginCategory, size, balanceType) {
+    if (types_1.isVariant(balanceType, 'deposit')) {
+        const assetWeight = spotBalance_1.calculateAssetWeight(size, market, marginCategory);
+        return numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
+    }
+    else {
+        const liabilityWeight = spotBalance_1.calculateLiabilityWeight(size, market, marginCategory);
+        return liabilityWeight.sub(numericConstants_1.MARGIN_PRECISION).toNumber();
+    }
+}
+exports.calculateSpotMarketMarginRatio = calculateSpotMarketMarginRatio;

package/lib/math/spotPosition.js

@@ -11,12 +11,12 @@ function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceDa
     const tokenAmount = spotBalance_1.getSignedTokenAmount(spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
     const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
-    if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
-        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+    if (tokenAmountAllBidsFill.abs().gt(tokenAmountAllAsksFill.abs())) {
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
     }
     else {
-        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
     }
 }

package/lib/user.d.ts

@@ -6,7 +6,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { DriftClient } from './driftClient';
 import { MarginCategory, Order, UserAccount, PerpPosition, SpotPosition, PerpMarketAccount } from './types';
 import { UserAccountSubscriber, UserAccountEvents, DataAndSlot } from './accounts/types';
-import { PositionDirection, BN, SpotMarketAccount } from '.';
+import { PositionDirection, BN, SpotMarketAccount, MarketType } from '.';
 import { OraclePriceData } from './oracles/types';
 import { UserConfig } from './userConfig';
 export declare class User {
@@ -80,8 +80,8 @@ export declare class User {
      * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION
      */
-    getBuyingPower(marketIndex: number): BN;
-    getBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex: number, freeCollateral: BN, baseAssetAmount: BN): BN;
+    getPerpBuyingPower(marketIndex: number): BN;
+    getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex: number, freeCollateral: BN, baseAssetAmount: BN): BN;
     /**
      * calculates Free Collateral = Total collateral - initial margin requirement
      * @returns : Precision QUOTE_PRECISION
@@ -110,10 +110,16 @@ export declare class User {
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex?: number): BN;
+    getSpotMarketAssetAndLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, now?: BN): {
+        totalAssetValue: BN;
+        totalLiabilityValue: BN;
+    };
     getSpotMarketLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
     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;
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
@@ -146,6 +152,12 @@ export declare class User {
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage(): BN;
+    getLeverageComponents(): {
+        perpLiabilityValue: BN;
+        perpPnl: BN;
+        spotAssetValue: BN;
+        spotLiabilityValue: BN;
+    };
     getTotalLiabilityValue(marginCategory?: MarginCategory): BN;
     getTotalAssetValue(marginCategory?: MarginCategory): BN;
     /**
@@ -153,12 +165,19 @@ export declare class User {
      * @params category {Initial, Maintenance}
      * @returns : Precision TEN_THOUSAND
      */
-    getMaxLeverage(marketIndex: number, category?: MarginCategory): BN;
+    getMaxLeverageForPerp(perpMarketIndex: number, category?: MarginCategory): BN;
     /**
-     * calculates margin ratio: total collateral / |total position value|
+     * calculates max allowable leverage exceeding hitting requirement category
+     * @param spotMarketIndex
+     * @param direction
      * @returns : Precision TEN_THOUSAND
      */
-    getMarginRatio(marginCategory?: MarginCategory): BN;
+    getMaxLeverageForSpot(spotMarketIndex: number, direction: PositionDirection): BN;
+    /**
+     * calculates margin ratio: 1 / leverage
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMarginRatio(): BN;
     canBeLiquidated(): boolean;
     isBeingLiquidated(): boolean;
     isBankrupt(): boolean;
@@ -172,7 +191,7 @@ export declare class User {
      * @param marketIndex
      * @returns Precision : PRICE_PRECISION
      */
-    spotLiquidationPrice(marketIndex: number): BN;
+    spotLiquidationPrice(marketIndex: number, positionBaseSizeChange?: BN): BN;
     /**
      * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
      * @param marketIndex
@@ -210,15 +229,27 @@ export declare class User {
      * @param tradeSide
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
-    getMaxTradeSizeUSDC(targetMarketIndex: number, tradeSide: PositionDirection): BN;
+    getMaxTradeSizeUSDCForPerp(targetMarketIndex: number, tradeSide: PositionDirection): BN;
+    /**
+     * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
+     *
+     * @param targetMarketIndex
+     * @param direction
+     * @param currentQuoteAssetValue
+     * @param currentSpotMarketNetValue
+     * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
+     */
+    getMaxTradeSizeUSDCForSpot(targetMarketIndex: number, direction: PositionDirection, currentQuoteAssetValue?: BN, currentSpotMarketNetValue?: BN): BN;
     /**
      * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
      * @param targetMarketIndex
-     * @param positionMarketIndex
+     * @param: targetMarketType
      * @param tradeQuoteAmount
+     * @param tradeSide
+     * @param includeOpenOrders
      * @returns leverageRatio : Precision TEN_THOUSAND
      */
-    accountLeverageRatioAfterTrade(targetMarketIndex: number, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
+    accountLeverageRatioAfterTrade(targetMarketIndex: number, targetMarketType: MarketType, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
     /**
      * Calculates how much fee will be taken for a given sized trade
      * @param quoteAmount