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

package/lib/user.js

@@ -420,7 +420,7 @@ class User {
         return this.getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, worstCaseBaseAssetAmount);
     }
     getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, baseAssetAmount) {
-        const marginRatio = (0, _1.calculateMarketMarginRatio)(this.driftClient.getPerpMarketAccount(marketIndex), baseAssetAmount, 'Initial', this.getUserAccount().maxMarginRatio);
+        const marginRatio = (0, _1.calculateMarketMarginRatio)(this.driftClient.getPerpMarketAccount(marketIndex), baseAssetAmount, 'Initial', this.getUserAccount().maxMarginRatio, this.isHighLeverageMode());
         return freeCollateral.mul(numericConstants_1.MARGIN_PRECISION).div(new _1.BN(marginRatio));
     }
     /**
@@ -787,7 +787,7 @@ class User {
             liabilityValue = (0, _1.calculatePerpLiabilityValue)(baseAssetAmount, valuationPrice, (0, types_1.isVariant)(market.contractType, 'prediction'));
         }
         if (marginCategory) {
-            let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio));
+            let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio, this.isHighLeverageMode()));
             if (liquidationBuffer !== undefined) {
                 marginRatio = marginRatio.add(liquidationBuffer);
             }
@@ -1032,7 +1032,7 @@ class User {
             .mul(numericConstants_1.PRICE_PRECISION)
             .div(marketPrice));
         // margin ratio incorporting upper bound on size
-        let marginRatio = (0, _1.calculateMarketMarginRatio)(market, maxSize, marginCategory, this.getUserAccount().maxMarginRatio);
+        let marginRatio = (0, _1.calculateMarketMarginRatio)(market, maxSize, marginCategory, this.getUserAccount().maxMarginRatio, this.isHighLeverageMode());
         // use more fesible size since imf factor activated
         let attempts = 0;
         while (marginRatio > rawMarginRatio + 1e-4 && attempts < 10) {
@@ -1043,7 +1043,7 @@ class User {
                 .mul(numericConstants_1.PRICE_PRECISION)
                 .div(marketPrice));
             // margin ratio incorporting more fesible target size
-            marginRatio = (0, _1.calculateMarketMarginRatio)(market, targetSize, marginCategory, this.getUserAccount().maxMarginRatio);
+            marginRatio = (0, _1.calculateMarketMarginRatio)(market, targetSize, marginCategory, this.getUserAccount().maxMarginRatio, this.isHighLeverageMode());
             attempts += 1;
         }
         // how much more liabilities can be opened w remaining free collateral
@@ -1133,6 +1133,9 @@ class User {
     isBankrupt() {
         return (this.getUserAccount().status & types_1.UserStatus.BANKRUPT) > 0;
     }
+    isHighLeverageMode() {
+        return (0, types_1.isVariant)(this.getUserAccount().marginMode, 'highLeverage');
+    }
     /**
      * Checks if any user position cumulative funding differs from respective market cumulative funding
      * @returns
@@ -1279,7 +1282,7 @@ class User {
                 baseAssetAmount = perpPosition.baseAssetAmount;
                 liabilityValue = (0, _1.calculatePerpLiabilityValue)(baseAssetAmount, oraclePrice, (0, types_1.isVariant)(market.contractType, 'prediction'));
             }
-            const marginRatio = (0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), 'Maintenance');
+            const marginRatio = (0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), 'Maintenance', this.getUserAccount().maxMarginRatio, this.isHighLeverageMode());
             return liabilityValue.mul(new _1.BN(marginRatio)).div(numericConstants_1.MARGIN_PRECISION);
         };
         const freeCollateralConsumptionBefore = calculateMarginRequirement(perpPosition);
@@ -1295,7 +1298,7 @@ class User {
         // zero if include orders == false
         const orderBaseAssetAmount = baseAssetAmount.sub(perpPosition.baseAssetAmount);
         const proposedBaseAssetAmount = baseAssetAmount.add(positionBaseSizeChange);
-        const marginRatio = (0, _1.calculateMarketMarginRatio)(market, proposedBaseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio);
+        const marginRatio = (0, _1.calculateMarketMarginRatio)(market, proposedBaseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio, this.isHighLeverageMode());
         const marginRatioQuotePrecision = new _1.BN(marginRatio)
             .mul(numericConstants_1.QUOTE_PRECISION)
             .div(numericConstants_1.MARGIN_PRECISION);
@@ -1368,11 +1371,12 @@ 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);
+        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 ?
+        );
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
@@ -2002,7 +2006,7 @@ class User {
             this.driftClient.getOracleDataForPerpMarket(perpMarket.marketIndex);
         const oraclePrice = _oraclePriceData.price;
         const { worstCaseBaseAssetAmount: worstCaseBaseAmount, worstCaseLiabilityValue, } = (0, _1.calculateWorstCasePerpLiabilityValue)(settledLpPosition, perpMarket, oraclePrice);
-        const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio));
+        const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio, this.isHighLeverageMode()));
         const _quoteOraclePriceData = quoteOraclePriceData ||
             this.driftClient.getOracleDataForSpotMarket(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
         let marginRequirement = worstCaseLiabilityValue

package/package.json

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

package/src/addresses/pda.ts

@@ -300,3 +300,12 @@ export function getTokenProgramForSpotMarket(
 	}
 	return TOKEN_PROGRAM_ID;
 }
+
+export function getHighLeverageModeConfigPublicKey(
+	programId: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('high_leverage_mode_config'))],
+		programId
+	)[0];
+}

package/src/adminClient.ts

@@ -32,6 +32,7 @@ import {
 	getOpenbookV2FulfillmentConfigPublicKey,
 	getPythPullOraclePublicKey,
 	getUserStatsAccountPublicKey,
+	getHighLeverageModeConfigPublicKey,
 } from './addresses/pda';
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
@@ -1268,6 +1269,50 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updatePerpMarketHighLeverageMarginRatio(
+		perpMarketIndex: number,
+		marginRatioInitial: number,
+		marginRatioMaintenance: number
+	): Promise<TransactionSignature> {
+		const updatePerpMarketHighLeverageMarginRatioIx =
+			await this.getUpdatePerpMarketHighLeverageMarginRatioIx(
+				perpMarketIndex,
+				marginRatioInitial,
+				marginRatioMaintenance
+			);
+
+		const tx = await this.buildTransaction(
+			updatePerpMarketHighLeverageMarginRatioIx
+		);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdatePerpMarketHighLeverageMarginRatioIx(
+		perpMarketIndex: number,
+		marginRatioInitial: number,
+		marginRatioMaintenance: number
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.updatePerpMarketHighLeverageMarginRatio(
+			marginRatioInitial,
+			marginRatioMaintenance,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+				},
+			}
+		);
+	}
+
 	public async updatePerpMarketImfFactor(
 		perpMarketIndex: number,
 		imfFactor: number,
@@ -3847,4 +3892,73 @@ export class AdminClient extends DriftClient {
 			}
 		);
 	}
+
+	public async initializeHighLeverageModeConfig(
+		maxUsers: number
+	): Promise<TransactionSignature> {
+		const initializeHighLeverageModeConfigIx =
+			await this.getInitializeHighLeverageModeConfigIx(maxUsers);
+
+		const tx = await this.buildTransaction(initializeHighLeverageModeConfigIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getInitializeHighLeverageModeConfigIx(
+		maxUsers: number
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.initializeHighLeverageModeConfig(
+			maxUsers,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					highLeverageModeConfig: getHighLeverageModeConfigPublicKey(
+						this.program.programId
+					),
+				},
+			}
+		);
+	}
+
+	public async updateUpdateHighLeverageModeConfig(
+		maxUsers: number,
+		reduceOnly: boolean
+	): Promise<TransactionSignature> {
+		const updateHighLeverageModeConfigIx =
+			await this.getUpdateHighLeverageModeConfigIx(maxUsers, reduceOnly);
+
+		const tx = await this.buildTransaction(updateHighLeverageModeConfigIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdateHighLeverageModeConfigIx(
+		maxUsers: number,
+		reduceOnly: boolean
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.updateHighLeverageModeConfig(
+			maxUsers,
+			reduceOnly,
+			{
+				accounts: {
+					admin: this.isSubscribed
+						? this.getStateAccount().admin
+						: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					highLeverageModeConfig: getHighLeverageModeConfigPublicKey(
+						this.program.programId
+					),
+				},
+			}
+		);
+	}
 }

package/src/config.ts

@@ -114,16 +114,25 @@ export const initialize = (props: {
 	return currentConfig;
 };
 
-export function getMarketsAndOraclesForSubscription(env: DriftEnv): {
+export function getMarketsAndOraclesForSubscription(
+	env: DriftEnv,
+	perpMarkets?: PerpMarketConfig[],
+	spotMarkets?: SpotMarketConfig[]
+): {
 	perpMarketIndexes: number[];
 	spotMarketIndexes: number[];
 	oracleInfos: OracleInfo[];
 } {
+	const perpMarketsToUse =
+		perpMarkets?.length > 0 ? perpMarkets : PerpMarkets[env];
+	const spotMarketsToUse =
+		spotMarkets?.length > 0 ? spotMarkets : SpotMarkets[env];
+
 	const perpMarketIndexes = [];
 	const spotMarketIndexes = [];
 	const oracleInfos = new Map<string, OracleInfo>();
 
-	for (const market of PerpMarkets[env]) {
+	for (const market of perpMarketsToUse) {
 		perpMarketIndexes.push(market.marketIndex);
 		oracleInfos.set(market.oracle.toString(), {
 			publicKey: market.oracle,
@@ -131,7 +140,7 @@ export function getMarketsAndOraclesForSubscription(env: DriftEnv): {
 		});
 	}
 
-	for (const spotMarket of SpotMarkets[env]) {
+	for (const spotMarket of spotMarketsToUse) {
 		spotMarketIndexes.push(spotMarket.marketIndex);
 		oracleInfos.set(spotMarket.oracle.toString(), {
 			publicKey: spotMarket.oracle,

package/src/constants/perpMarkets.ts

@@ -728,9 +728,9 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		symbol: 'CLOUD-PERP',
 		baseAssetSymbol: 'CLOUD',
 		marketIndex: 31,
-		oracle: new PublicKey('4FG7UyPkszGvcSVCCKaLSZsArGjyxitwhJeQhYu2bFTS'),
+		oracle: new PublicKey('FNFejcXENaPgKaCTfstew9vSSvdQPnXjGTkJjUnnYvHU'),
 		launchTs: 1717597648000,
-		oracleSource: OracleSource.SWITCHBOARD,
+		oracleSource: OracleSource.SWITCHBOARD_ON_DEMAND,
 	},
 	{
 		fullName: 'IO',
@@ -896,6 +896,48 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1727965864000,
 		oracleSource: OracleSource.Prelaunch,
 	},
+	{
+		fullName: 'DeBridge',
+		category: ['Bridge'],
+		symbol: 'DBR-PERP',
+		baseAssetSymbol: 'DBR',
+		marketIndex: 47,
+		oracle: new PublicKey('53j4mz7cQV7mAZekKbV3n2L4bY7jY6eXdgaTkWDLYxq4'),
+		launchTs: 1728574493000,
+		oracleSource: OracleSource.PYTH_PULL,
+		pythFeedId:
+			'0xf788488fe2df341b10a498e0a789f03209c0938d9ed04bc521f8224748d6d236',
+	},
+	{
+		fullName: 'WLF-5B-1W',
+		category: ['Prediction'],
+		symbol: 'WLF-5B-1W-BET',
+		baseAssetSymbol: 'WLF-5B-1W',
+		marketIndex: 48,
+		oracle: new PublicKey('7LpRfPaWR7cQqN7CMkCmZjEQpWyqso5LGuKCvDXH5ZAr'),
+		launchTs: 1728574493000,
+		oracleSource: OracleSource.Prelaunch,
+	},
+	{
+		fullName: 'VRSTPN-WIN-F1-24-DRVRS-CHMP',
+		category: ['Prediction', 'Sport'],
+		symbol: 'VRSTPN-WIN-F1-24-DRVRS-CHMP-BET',
+		baseAssetSymbol: 'VRSTPN-WIN-F1-24-DRVRS-CHMP',
+		marketIndex: 49,
+		oracle: new PublicKey('E36rvXEwysWeiToXCpWfHVADd8bzzyR4w83ZSSwxAxqG'),
+		launchTs: 1729209600000,
+		oracleSource: OracleSource.Prelaunch,
+	},
+	{
+		fullName: 'LNDO-WIN-F1-24-US-GP',
+		category: ['Prediction', 'Sport'],
+		symbol: 'LNDO-WIN-F1-24-US-GP-BET',
+		baseAssetSymbol: 'LNDO-WIN-F1-24-US-GP',
+		marketIndex: 50,
+		oracle: new PublicKey('6AVy1y9SnJECnosQaiK2uY1kcT4ZEBf1F4DMvhxgvhUo'),
+		launchTs: 1729209600000,
+		oracleSource: OracleSource.Prelaunch,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/constants/spotMarkets.ts

@@ -374,8 +374,8 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 	{
 		symbol: 'CLOUD',
 		marketIndex: 21,
-		oracle: new PublicKey('4FG7UyPkszGvcSVCCKaLSZsArGjyxitwhJeQhYu2bFTS'),
-		oracleSource: OracleSource.SWITCHBOARD,
+		oracle: new PublicKey('FNFejcXENaPgKaCTfstew9vSSvdQPnXjGTkJjUnnYvHU'),
+		oracleSource: OracleSource.SWITCHBOARD_ON_DEMAND,
 		mint: new PublicKey('CLoUDKc4Ane7HeQcPpE3YHnznRxhMimJ4MyaUqyHFzAu'),
 		precision: new BN(10).pow(NINE),
 		precisionExp: NINE,

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/driftClient.ts

@@ -19,6 +19,7 @@ import {
 } from '@solana/spl-token';
 import {
 	DriftClientMetricsEvents,
+	HighLeverageModeConfig,
 	isVariant,
 	IWallet,
 	MakerInfo,
@@ -82,6 +83,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import {
 	getDriftSignerPublicKey,
 	getDriftStateAccountPublicKey,
+	getHighLeverageModeConfigPublicKey,
 	getInsuranceFundStakeAccountPublicKey,
 	getOpenbookV2FulfillmentConfigPublicKey,
 	getPerpMarketPublicKey,
@@ -4936,6 +4938,79 @@ export class DriftClient {
 		});
 	}
 
+	public async updateUserFuelBonus(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		userAuthority: PublicKey,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getUpdateUserFuelBonusIx(
+					userAccountPublicKey,
+					user,
+					userAuthority
+				),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getUpdateUserFuelBonusIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		userAuthority: PublicKey
+	): Promise<TransactionInstruction> {
+		const userStatsAccountPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAuthority
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [userAccount],
+		});
+
+		return await this.program.instruction.updateUserFuelBonus({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				userStats: userStatsAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async updateUserStatsReferrerInfo(
+		userStatsAccountPublicKey: PublicKey,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getUpdateUserStatsReferrerInfoIx(userStatsAccountPublicKey),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getUpdateUserStatsReferrerInfoIx(
+		userStatsAccountPublicKey: PublicKey
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.updateUserStatsReferrerInfo({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				userStats: userStatsAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+		});
+	}
+
 	public async updateUserOpenOrdersCount(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
@@ -6499,7 +6574,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],
 		});
@@ -8056,6 +8134,96 @@ export class DriftClient {
 		return [postIxs, encodedVaaKeypair];
 	}
 
+	public async enableUserHighLeverageMode(
+		subAccountId: number,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getEnableHighLeverageModeIx(subAccountId),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getEnableHighLeverageModeIx(subAccountId: number) {
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(subAccountId)],
+		});
+
+		const ix = await this.program.instruction.enableUserHighLeverageMode(
+			subAccountId,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: getUserAccountPublicKeySync(
+						this.program.programId,
+						this.wallet.publicKey,
+						subAccountId
+					),
+					authority: this.wallet.publicKey,
+					highLeverageModeConfig: getHighLeverageModeConfigPublicKey(
+						this.program.programId
+					),
+				},
+				remainingAccounts,
+			}
+		);
+
+		return ix;
+	}
+
+	public async disableUserHighLeverageMode(
+		user: PublicKey,
+		userAccount?: UserAccount,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getDisableHighLeverageModeIx(user, userAccount),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	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(),
+				user,
+				authority: this.wallet.publicKey,
+				highLeverageModeConfig: getHighLeverageModeConfigPublicKey(
+					this.program.programId
+				),
+			},
+			remainingAccounts,
+		});
+
+		return ix;
+	}
+
+	public async fetchHighLeverageModeConfig(): Promise<HighLeverageModeConfig> {
+		const config = await this.program.account.highLeverageModeConfig.fetch(
+			getHighLeverageModeConfigPublicKey(this.program.programId)
+		);
+		return config as HighLeverageModeConfig;
+	}
+
 	private handleSignedTransaction(signedTxs: SignedTxData[]) {
 		if (this.enableMetricsEvents && this.metricsEventEmitter) {
 			this.metricsEventEmitter.emit('txSigned', signedTxs);