@drift-labs/sdk 2.97.0-beta.16 → 2.97.0-beta.18

package/VERSION

@@ -1 +1 @@
-2.97.0-beta.16
+2.97.0-beta.18

package/lib/driftClient.d.ts

@@ -791,8 +791,8 @@ export declare class DriftClient {
     private getBuildEncodedVaaIxs;
     enableUserHighLeverageMode(subAccountId: number, txParams?: TxParams): Promise<TransactionSignature>;
     getEnableHighLeverageModeIx(subAccountId: number): Promise<anchor.web3.TransactionInstruction>;
-    disableUserHighLeverageMode(user: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
-    getDisableHighLeverageModeIx(user: PublicKey): Promise<anchor.web3.TransactionInstruction>;
+    disableUserHighLeverageMode(user: PublicKey, userAccount?: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
+    getDisableHighLeverageModeIx(user: PublicKey, userAccount?: UserAccount): Promise<anchor.web3.TransactionInstruction>;
     fetchHighLeverageModeConfig(): Promise<HighLeverageModeConfig>;
     private handleSignedTransaction;
     private handlePreSignedTransaction;

package/lib/driftClient.js

@@ -3451,7 +3451,10 @@ class DriftClient {
         const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+            userAccounts: [
+                userAccount,
+                ...makerInfos.map((makerInfo) => makerInfo.makerUserAccount),
+            ],
             useMarketLastSlotCache: true,
             writablePerpMarketIndexes: [marketIndex],
         });
@@ -4259,6 +4262,9 @@ class DriftClient {
         return txSig;
     }
     async getEnableHighLeverageModeIx(subAccountId) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(subAccountId)],
+        });
         const ix = await this.program.instruction.enableUserHighLeverageMode(subAccountId, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -4266,14 +4272,20 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 highLeverageModeConfig: (0, pda_1.getHighLeverageModeConfigPublicKey)(this.program.programId),
             },
+            remainingAccounts,
         });
         return ix;
     }
-    async disableUserHighLeverageMode(user, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getDisableHighLeverageModeIx(user), txParams), [], this.opts);
+    async disableUserHighLeverageMode(user, userAccount, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getDisableHighLeverageModeIx(user, userAccount), txParams), [], this.opts);
         return txSig;
     }
-    async getDisableHighLeverageModeIx(user) {
+    async getDisableHighLeverageModeIx(user, userAccount) {
+        const remainingAccounts = userAccount
+            ? this.getRemainingAccounts({
+                userAccounts: [userAccount],
+            })
+            : undefined;
         const ix = await this.program.instruction.disableUserHighLeverageMode({
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -4281,6 +4293,7 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 highLeverageModeConfig: (0, pda_1.getHighLeverageModeConfigPublicKey)(this.program.programId),
             },
+            remainingAccounts,
         });
         return ix;
     }

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

@@ -1371,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.16",
+	"version": "2.97.0-beta.18",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/driftClient.ts

@@ -6547,7 +6547,10 @@ export class DriftClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				userAccount,
+				...makerInfos.map((makerInfo) => makerInfo.makerUserAccount),
+			],
 			useMarketLastSlotCache: true,
 			writablePerpMarketIndexes: [marketIndex],
 		});
@@ -8120,6 +8123,10 @@ export class DriftClient {
 	}
 
 	public async getEnableHighLeverageModeIx(subAccountId: number) {
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(subAccountId)],
+		});
+
 		const ix = await this.program.instruction.enableUserHighLeverageMode(
 			subAccountId,
 			{
@@ -8135,6 +8142,7 @@ export class DriftClient {
 						this.program.programId
 					),
 				},
+				remainingAccounts,
 			}
 		);
 
@@ -8143,11 +8151,12 @@ export class DriftClient {
 
 	public async disableUserHighLeverageMode(
 		user: PublicKey,
+		userAccount?: UserAccount,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(
-				await this.getDisableHighLeverageModeIx(user),
+				await this.getDisableHighLeverageModeIx(user, userAccount),
 				txParams
 			),
 			[],
@@ -8156,7 +8165,16 @@ export class DriftClient {
 		return txSig;
 	}
 
-	public async getDisableHighLeverageModeIx(user: PublicKey) {
+	public async getDisableHighLeverageModeIx(
+		user: PublicKey,
+		userAccount?: UserAccount
+	) {
+		const remainingAccounts = userAccount
+			? this.getRemainingAccounts({
+					userAccounts: [userAccount],
+			  })
+			: undefined;
+
 		const ix = await this.program.instruction.disableUserHighLeverageMode({
 			accounts: {
 				state: await this.getStatePublicKey(),
@@ -8166,6 +8184,7 @@ export class DriftClient {
 					this.program.programId
 				),
 			},
+			remainingAccounts,
 		});
 
 		return ix;

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

@@ -2613,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
 		);
 	}