@drift-labs/sdk 2.97.0-beta.15 → 2.97.0-beta.17

package/VERSION

@@ -1 +1 @@
-2.97.0-beta.15
+2.97.0-beta.17

package/lib/decode/user.js

@@ -296,6 +296,15 @@ function decodeUser(buffer) {
     offset += 1;
     const hasOpenAuction = buffer.readUInt8(offset) === 1;
     offset += 1;
+    let marginMode;
+    const marginModeNum = buffer.readUInt8(offset);
+    if (marginModeNum === 0) {
+        marginMode = __1.MarginMode.DEFAULT;
+    }
+    else {
+        marginMode = __1.MarginMode.HIGH_LEVERAGE;
+    }
+    offset += 1;
     // @ts-ignore
     return {
         authority,
@@ -324,6 +333,7 @@ function decodeUser(buffer) {
         hasOpenOrder,
         openAuctions,
         hasOpenAuction,
+        marginMode,
     };
 }
 exports.decodeUser = decodeUser;

package/lib/math/margin.d.ts

@@ -21,19 +21,19 @@ export declare function calculateWorstCasePerpLiabilityValue(perpPosition: PerpP
     worstCaseBaseAssetAmount: BN;
     worstCaseLiabilityValue: BN;
 };
-export declare function calculatePerpLiabilityValue(baseAssetAmount: BN, oraclePrice: BN, isPredictionMarket: boolean): BN;
+export declare function calculatePerpLiabilityValue(baseAssetAmount: BN, price: BN, isPredictionMarket: boolean): BN;
 /**
  * Calculates the margin required to open a trade, in quote amount. Only accounts for the trade size as a scalar value, does not account for the trade direction or current open positions and whether the trade would _actually_ be risk-increasing and use any extra collateral.
  * @param targetMarketIndex
  * @param baseSize
  * @returns
  */
-export declare function calculateMarginUSDCRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, userMaxMarginRatio?: number, userHighLeverageMode?: boolean): BN;
+export declare function calculateMarginUSDCRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, userMaxMarginRatio?: number, userHighLeverageMode?: boolean, entryPrice?: BN): BN;
 /**
  * Similar to calculatetMarginUSDCRequiredForTrade, but calculates how much of a given collateral is required to cover the margin requirements for a given trade. Basically does the same thing as getMarginUSDCRequiredForTrade but also accounts for asset weight of the selected collateral.
  *
  * Returns collateral required in the precision of the target collateral market.
  */
-export declare function calculateCollateralDepositRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, collateralIndex: number, userMaxMarginRatio?: number, userHighLeverageMode?: boolean): BN;
+export declare function calculateCollateralDepositRequiredForTrade(driftClient: DriftClient, targetMarketIndex: number, baseSize: BN, collateralIndex: number, userMaxMarginRatio?: number, userHighLeverageMode?: boolean, estEntryPrice?: BN): BN;
 export declare function calculateCollateralValueOfDeposit(driftClient: DriftClient, collateralIndex: number, baseSize: BN): BN;
 export declare function calculateLiquidationPrice(freeCollateral: BN, freeCollateralDelta: BN, oraclePrice: BN): BN;

package/lib/math/margin.js

@@ -100,20 +100,20 @@ function calculateWorstCasePerpLiabilityValue(perpPosition, perpMarket, oraclePr
     }
 }
 exports.calculateWorstCasePerpLiabilityValue = calculateWorstCasePerpLiabilityValue;
-function calculatePerpLiabilityValue(baseAssetAmount, oraclePrice, isPredictionMarket) {
+function calculatePerpLiabilityValue(baseAssetAmount, price, isPredictionMarket) {
     if (isPredictionMarket) {
         if (baseAssetAmount.gt(numericConstants_1.ZERO)) {
-            return baseAssetAmount.mul(oraclePrice).div(numericConstants_1.BASE_PRECISION);
+            return baseAssetAmount.mul(price).div(numericConstants_1.BASE_PRECISION);
         }
         else {
             return baseAssetAmount
                 .abs()
-                .mul(numericConstants_1.MAX_PREDICTION_PRICE.sub(oraclePrice))
+                .mul(numericConstants_1.MAX_PREDICTION_PRICE.sub(price))
                 .div(numericConstants_1.BASE_PRECISION);
         }
     }
     else {
-        return baseAssetAmount.abs().mul(oraclePrice).div(numericConstants_1.BASE_PRECISION);
+        return baseAssetAmount.abs().mul(price).div(numericConstants_1.BASE_PRECISION);
     }
 }
 exports.calculatePerpLiabilityValue = calculatePerpLiabilityValue;
@@ -123,10 +123,10 @@ exports.calculatePerpLiabilityValue = calculatePerpLiabilityValue;
  * @param baseSize
  * @returns
  */
-function calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, userHighLeverageMode) {
+function calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, userHighLeverageMode, entryPrice) {
     const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
-    const oracleData = driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex);
-    const perpLiabilityValue = calculatePerpLiabilityValue(baseSize, oracleData.price, (0, types_1.isVariant)(targetMarket.contractType, 'prediction'));
+    const price = entryPrice !== null && entryPrice !== void 0 ? entryPrice : driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
+    const perpLiabilityValue = calculatePerpLiabilityValue(baseSize, price, (0, types_1.isVariant)(targetMarket.contractType, 'prediction'));
     const marginRequired = new anchor_1.BN((0, __1.calculateMarketMarginRatio)(targetMarket, baseSize.abs(), 'Initial', userMaxMarginRatio, userHighLeverageMode))
         .mul(perpLiabilityValue)
         .div(numericConstants_1.MARGIN_PRECISION);
@@ -138,8 +138,8 @@ exports.calculateMarginUSDCRequiredForTrade = calculateMarginUSDCRequiredForTrad
  *
  * Returns collateral required in the precision of the target collateral market.
  */
-function calculateCollateralDepositRequiredForTrade(driftClient, targetMarketIndex, baseSize, collateralIndex, userMaxMarginRatio, userHighLeverageMode) {
-    const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, userHighLeverageMode);
+function calculateCollateralDepositRequiredForTrade(driftClient, targetMarketIndex, baseSize, collateralIndex, userMaxMarginRatio, userHighLeverageMode, estEntryPrice) {
+    const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(driftClient, targetMarketIndex, baseSize, userMaxMarginRatio, userHighLeverageMode, estEntryPrice);
     const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
     const collateralOracleData = driftClient.getOracleDataForSpotMarket(collateralIndex);
     const scaledAssetWeight = (0, __1.calculateScaledInitialAssetWeight)(collateralMarket, collateralOracleData.price);

package/lib/user.d.ts

@@ -280,7 +280,7 @@ export declare class User {
      * @returns : Precision PRICE_PRECISION
      */
     liquidationPriceAfterClose(positionMarketIndex: number, closeQuoteAmount: BN, estimatedEntryPrice?: BN): BN;
-    getMarginUSDCRequiredForTrade(targetMarketIndex: number, baseSize: BN): BN;
+    getMarginUSDCRequiredForTrade(targetMarketIndex: number, baseSize: BN, estEntryPrice?: BN): BN;
     getCollateralDepositRequiredForTrade(targetMarketIndex: number, baseSize: BN, collateralIndex: number): BN;
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.

package/lib/user.js

@@ -1134,10 +1134,7 @@ class User {
         return (this.getUserAccount().status & types_1.UserStatus.BANKRUPT) > 0;
     }
     isHighLeverageMode() {
-        if (this.getUserAccount().marginMode) {
-            return (0, types_1.isVariant)(this.getUserAccount().marginMode, 'highLeverage');
-        }
-        return false;
+        return (0, types_1.isVariant)(this.getUserAccount().marginMode, 'highLeverage');
     }
     /**
      * Checks if any user position cumulative funding differs from respective market cumulative funding
@@ -1374,8 +1371,8 @@ class User {
             .neg();
         return this.liquidationPrice(positionMarketIndex, closeBaseAmount, estimatedEntryPrice);
     }
-    getMarginUSDCRequiredForTrade(targetMarketIndex, baseSize) {
-        return (0, margin_1.calculateMarginUSDCRequiredForTrade)(this.driftClient, targetMarketIndex, baseSize, this.getUserAccount().maxMarginRatio);
+    getMarginUSDCRequiredForTrade(targetMarketIndex, baseSize, estEntryPrice) {
+        return (0, margin_1.calculateMarginUSDCRequiredForTrade)(this.driftClient, targetMarketIndex, baseSize, this.getUserAccount().maxMarginRatio, undefined, estEntryPrice);
     }
     getCollateralDepositRequiredForTrade(targetMarketIndex, baseSize, collateralIndex) {
         return (0, margin_1.calculateCollateralDepositRequiredForTrade)(this.driftClient, targetMarketIndex, baseSize, collateralIndex, this.getUserAccount().maxMarginRatio, false // assume user cant be high leverage if they havent created user account ?

package/package.json

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

package/src/decode/user.ts

@@ -11,7 +11,7 @@ import {
 	UserAccount,
 } from '../types';
 import { PublicKey } from '@solana/web3.js';
-import { BN } from '../';
+import { BN, MarginMode } from '../';
 import { ZERO } from '../';
 
 function readUnsignedBigInt64LE(buffer: Buffer, offset: number): BN {
@@ -326,6 +326,15 @@ export function decodeUser(buffer: Buffer): UserAccount {
 	const hasOpenAuction = buffer.readUInt8(offset) === 1;
 	offset += 1;
 
+	let marginMode: MarginMode;
+	const marginModeNum = buffer.readUInt8(offset);
+	if (marginModeNum === 0) {
+		marginMode = MarginMode.DEFAULT;
+	} else {
+		marginMode = MarginMode.HIGH_LEVERAGE;
+	}
+	offset += 1;
+
 	// @ts-ignore
 	return {
 		authority,
@@ -354,5 +363,6 @@ export function decodeUser(buffer: Buffer): UserAccount {
 		hasOpenOrder,
 		openAuctions,
 		hasOpenAuction,
+		marginMode,
 	};
 }

package/src/math/margin.ts

@@ -187,20 +187,20 @@ export function calculateWorstCasePerpLiabilityValue(
 
 export function calculatePerpLiabilityValue(
 	baseAssetAmount: BN,
-	oraclePrice: BN,
+	price: BN,
 	isPredictionMarket: boolean
 ): BN {
 	if (isPredictionMarket) {
 		if (baseAssetAmount.gt(ZERO)) {
-			return baseAssetAmount.mul(oraclePrice).div(BASE_PRECISION);
+			return baseAssetAmount.mul(price).div(BASE_PRECISION);
 		} else {
 			return baseAssetAmount
 				.abs()
-				.mul(MAX_PREDICTION_PRICE.sub(oraclePrice))
+				.mul(MAX_PREDICTION_PRICE.sub(price))
 				.div(BASE_PRECISION);
 		}
 	} else {
-		return baseAssetAmount.abs().mul(oraclePrice).div(BASE_PRECISION);
+		return baseAssetAmount.abs().mul(price).div(BASE_PRECISION);
 	}
 }
 
@@ -215,16 +215,18 @@ export function calculateMarginUSDCRequiredForTrade(
 	targetMarketIndex: number,
 	baseSize: BN,
 	userMaxMarginRatio?: number,
-	userHighLeverageMode?: boolean
+	userHighLeverageMode?: boolean,
+	entryPrice?: BN
 ): BN {
 	const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
-	const oracleData = driftClient.getOracleDataForPerpMarket(
-		targetMarket.marketIndex
-	);
+
+	const price =
+		entryPrice ??
+		driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
 
 	const perpLiabilityValue = calculatePerpLiabilityValue(
 		baseSize,
-		oracleData.price,
+		price,
 		isVariant(targetMarket.contractType, 'prediction')
 	);
 
@@ -254,14 +256,16 @@ export function calculateCollateralDepositRequiredForTrade(
 	baseSize: BN,
 	collateralIndex: number,
 	userMaxMarginRatio?: number,
-	userHighLeverageMode?: boolean
+	userHighLeverageMode?: boolean,
+	estEntryPrice?: BN
 ): BN {
 	const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(
 		driftClient,
 		targetMarketIndex,
 		baseSize,
 		userMaxMarginRatio,
-		userHighLeverageMode
+		userHighLeverageMode,
+		estEntryPrice
 	);
 
 	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);

package/src/user.ts

@@ -2159,10 +2159,7 @@ export class User {
 	}
 
 	public isHighLeverageMode(): boolean {
-		if (this.getUserAccount().marginMode) {
-			return isVariant(this.getUserAccount().marginMode, 'highLeverage');
-		}
-		return false;
+		return isVariant(this.getUserAccount().marginMode, 'highLeverage');
 	}
 
 	/**
@@ -2616,13 +2613,16 @@ export class User {
 
 	public getMarginUSDCRequiredForTrade(
 		targetMarketIndex: number,
-		baseSize: BN
+		baseSize: BN,
+		estEntryPrice?: BN
 	): BN {
 		return calculateMarginUSDCRequiredForTrade(
 			this.driftClient,
 			targetMarketIndex,
 			baseSize,
-			this.getUserAccount().maxMarginRatio
+			this.getUserAccount().maxMarginRatio,
+			undefined,
+			estEntryPrice
 		);
 	}