@drift-labs/sdk 2.145.0-beta.3 → 2.146.0-alpha.13

package/src/driftClient.ts

@@ -57,7 +57,6 @@ import {
 	StateAccount,
 	SwapReduceOnly,
 	SignedMsgOrderParamsMessage,
-	TakerInfo,
 	TxParams,
 	UserAccount,
 	UserStatsAccount,
@@ -147,7 +146,11 @@ import {
 	QUOTE_SPOT_MARKET_INDEX,
 	ZERO,
 } from './constants/numericConstants';
-import { findDirectionToClose, positionIsAvailable } from './math/position';
+import {
+	calculateClaimablePnl,
+	findDirectionToClose,
+	positionIsAvailable,
+} from './math/position';
 import { getSignedTokenAmount, getTokenAmount } from './math/spotBalance';
 import { decodeName, DEFAULT_USER_NAME, encodeName } from './userName';
 import { MMOraclePriceData, OraclePriceData } from './oracles/types';
@@ -210,6 +213,8 @@ import nacl from 'tweetnacl';
 import { Slothash } from './slot/SlothashSubscriber';
 import { getOracleId } from './oracles/oracleId';
 import { SignedMsgOrderParams } from './types';
+import { TakerInfo } from './types';
+// BN is already imported globally in this file via other imports
 import { sha256 } from '@noble/hashes/sha256';
 import { getOracleConfidenceFromMMOracleData } from './oracles/utils';
 import { ConstituentMap } from './constituentMap/constituentMap';
@@ -219,6 +224,7 @@ import {
 	isBuilderOrderReferral,
 	isBuilderOrderCompleted,
 } from './math/builder';
+import { BigNum } from './factory/bigNum';
 import { TitanClient, SwapMode as TitanSwapMode } from './titan/titanClient';
 import { UnifiedSwapClient } from './swap/UnifiedSwapClient';
 
@@ -295,6 +301,46 @@ export class DriftClient {
 		return this._isSubscribed && this.accountSubscriber.isSubscribed;
 	}
 
+	private async getPrePlaceOrderIxs(
+		orderParams: OptionalOrderParams,
+		userAccount: UserAccount,
+		options?: { positionMaxLev?: number; isolatedPositionDepositAmount?: BN }
+	): Promise<TransactionInstruction[]> {
+		const preIxs: TransactionInstruction[] = [];
+
+		if (isVariant(orderParams.marketType, 'perp')) {
+			const { positionMaxLev, isolatedPositionDepositAmount } = options ?? {};
+
+			if (
+				isolatedPositionDepositAmount?.gt?.(ZERO) &&
+				this.isOrderIncreasingPosition(orderParams, userAccount)
+			) {
+				preIxs.push(
+					await this.getTransferIsolatedPerpPositionDepositIx(
+						isolatedPositionDepositAmount as BN,
+						orderParams.marketIndex,
+						userAccount.subAccountId
+					)
+				);
+			}
+
+			if (positionMaxLev) {
+				const marginRatio = Math.floor(
+					(1 / positionMaxLev) * MARGIN_PRECISION.toNumber()
+				);
+				preIxs.push(
+					await this.getUpdateUserPerpPositionCustomMarginRatioIx(
+						orderParams.marketIndex,
+						marginRatio,
+						userAccount.subAccountId
+					)
+				);
+			}
+		}
+
+		return preIxs;
+	}
+
 	public set isSubscribed(val: boolean) {
 		this._isSubscribed = val;
 	}
@@ -406,6 +452,8 @@ export class DriftClient {
 				resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
 				logResubMessages: config.accountSubscription?.logResubMessages,
 				commitment: config.accountSubscription?.commitment,
+				programUserAccountSubscriber:
+					config.accountSubscription?.programUserAccountSubscriber,
 			};
 			this.userStatsAccountSubscriptionConfig = {
 				type: 'websocket',
@@ -474,7 +522,10 @@ export class DriftClient {
 				}
 			);
 		} else {
-			this.accountSubscriber = new WebSocketDriftClientAccountSubscriber(
+			const accountSubscriberClass =
+				config.accountSubscription?.driftClientAccountSubscriber ??
+				WebSocketDriftClientAccountSubscriber;
+			this.accountSubscriber = new accountSubscriberClass(
 				this.program,
 				config.perpMarketIndexes ?? [],
 				config.spotMarketIndexes ?? [],
@@ -485,9 +536,7 @@ export class DriftClient {
 					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
 					logResubMessages: config.accountSubscription?.logResubMessages,
 				},
-				config.accountSubscription?.commitment,
-				config.accountSubscription?.perpMarketAccountSubscriber,
-				config.accountSubscription?.oracleAccountSubscriber
+				config.accountSubscription?.commitment
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
@@ -765,7 +814,6 @@ export class DriftClient {
 
 		return lookupTableAccount;
 	}
-
 	public async fetchAllLookupTableAccounts(): Promise<
 		AddressLookupTableAccount[]
 	> {
@@ -1743,7 +1791,6 @@ export class DriftClient {
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 		return txSig;
 	}
-
 	public async getUpdateUserCustomMarginRatioIx(
 		marginRatio: number,
 		subAccountId = 0
@@ -2457,6 +2504,15 @@ export class DriftClient {
 		return this.getTokenAmount(QUOTE_SPOT_MARKET_INDEX);
 	}
 
+	public getIsolatedPerpPositionTokenAmount(
+		perpMarketIndex: number,
+		subAccountId?: number
+	): BN {
+		return this.getUser(subAccountId).getIsolatePerpPositionTokenAmount(
+			perpMarketIndex
+		);
+	}
+
 	/**
 	 * 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.
@@ -2534,7 +2590,6 @@ export class DriftClient {
 			this.mustIncludeSpotMarketIndexes.add(spotMarketIndex);
 		});
 	}
-
 	getRemainingAccounts(params: RemainingAccountParams): AccountMeta[] {
 		const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } =
 			this.getRemainingAccountMapsForUsers(params.userAccounts);
@@ -3399,7 +3454,6 @@ export class DriftClient {
 			userAccountPublicKey,
 		};
 	}
-
 	public async createInitializeUserAccountAndDepositCollateral(
 		amount: BN,
 		userTokenAccount: PublicKey,
@@ -4056,6 +4110,263 @@ export class DriftClient {
 		);
 	}
 
+	async depositIntoIsolatedPerpPosition(
+		amount: BN,
+		perpMarketIndex: number,
+		userTokenAccount: PublicKey,
+		subAccountId?: number,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getDepositIntoIsolatedPerpPositionIx(
+					amount,
+					perpMarketIndex,
+					userTokenAccount,
+					subAccountId
+				),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	async getDepositIntoIsolatedPerpPositionIx(
+		amount: BN,
+		perpMarketIndex: number,
+		userTokenAccount: PublicKey,
+		subAccountId?: number
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority,
+			subAccountId ?? this.activeSubAccountId
+		);
+
+		const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+		const spotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
+		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [],
+			writableSpotMarketIndexes: [spotMarketIndex],
+			readablePerpMarketIndex: [perpMarketIndex],
+		});
+
+		const tokenProgram = this.getTokenProgramForSpotMarket(spotMarketAccount);
+		return await this.program.instruction.depositIntoIsolatedPerpPosition(
+			spotMarketIndex,
+			perpMarketIndex,
+			amount,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					spotMarketVault: spotMarketAccount.vault,
+					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					userTokenAccount: userTokenAccount,
+					authority: this.wallet.publicKey,
+					tokenProgram,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async transferIsolatedPerpPositionDeposit(
+		amount: BN,
+		perpMarketIndex: number,
+		subAccountId?: number,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const tx = await this.buildTransaction(
+			await this.getTransferIsolatedPerpPositionDepositIx(
+				amount,
+				perpMarketIndex,
+				subAccountId
+			),
+			txParams
+		);
+		const { txSig } = await this.sendTransaction(tx, [], {
+			...this.opts,
+			skipPreflight: true,
+		});
+		return txSig;
+	}
+
+	public async getTransferIsolatedPerpPositionDepositIx(
+		amount: BN,
+		perpMarketIndex: number,
+		subAccountId?: number,
+		noAmountBuffer?: boolean
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority,
+			subAccountId ?? this.activeSubAccountId
+		);
+
+		const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+		const spotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
+		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+		const user = await this.getUserAccount(subAccountId);
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [user],
+			writableSpotMarketIndexes: [spotMarketIndex],
+			readablePerpMarketIndex: [perpMarketIndex],
+		});
+
+		const amountWithBuffer =
+			noAmountBuffer || amount.eq(BigNum.fromPrint('-9223372036854775808').val)
+				? amount
+				: amount.add(amount.div(new BN(1000))); // .1% buffer
+
+		return await this.program.instruction.transferIsolatedPerpPositionDeposit(
+			spotMarketIndex,
+			perpMarketIndex,
+			amountWithBuffer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					spotMarketVault: spotMarketAccount.vault,
+					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async withdrawFromIsolatedPerpPosition(
+		amount: BN,
+		perpMarketIndex: number,
+		userTokenAccount: PublicKey,
+		subAccountId?: number,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const instructions =
+			await this.getWithdrawFromIsolatedPerpPositionIxsBundle(
+				amount,
+				perpMarketIndex,
+				subAccountId,
+				userTokenAccount
+			);
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(instructions, txParams)
+		);
+		return txSig;
+	}
+
+	public async getWithdrawFromIsolatedPerpPositionIxsBundle(
+		amount: BN,
+		perpMarketIndex: number,
+		subAccountId?: number,
+		userTokenAccount?: PublicKey
+	): Promise<TransactionInstruction[]> {
+		const userAccountPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority,
+			subAccountId ?? this.activeSubAccountId
+		);
+		const userAccount = this.getUserAccount(subAccountId);
+
+		const tokenAmountDeposited =
+			this.getIsolatedPerpPositionTokenAmount(perpMarketIndex);
+		const isolatedPositionUnrealizedPnl = calculateClaimablePnl(
+			this.getPerpMarketAccount(perpMarketIndex),
+			this.getSpotMarketAccount(
+				this.getPerpMarketAccount(perpMarketIndex).quoteSpotMarketIndex
+			),
+			userAccount.perpPositions.find((p) => p.marketIndex === perpMarketIndex),
+			this.getOracleDataForSpotMarket(
+				this.getPerpMarketAccount(perpMarketIndex).quoteSpotMarketIndex
+			)
+		);
+
+		const depositAmountPlusUnrealizedPnl = tokenAmountDeposited.add(
+			isolatedPositionUnrealizedPnl
+		);
+
+		const amountToWithdraw = amount.gt(depositAmountPlusUnrealizedPnl)
+			? BigNum.fromPrint('-9223372036854775808').val // min i64
+			: amount;
+		console.log('amountToWithdraw', amountToWithdraw.toString());
+		console.log('amount', amount.toString());
+
+		let associatedTokenAccount = userTokenAccount;
+		if (!associatedTokenAccount) {
+			const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+			const quoteSpotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
+			associatedTokenAccount = await this.getAssociatedTokenAccount(
+				quoteSpotMarketIndex
+			);
+		}
+
+		const withdrawIx = await this.getWithdrawFromIsolatedPerpPositionIx(
+			amountToWithdraw,
+			perpMarketIndex,
+			associatedTokenAccount,
+			subAccountId
+		);
+		const ixs = [withdrawIx];
+
+		const needsToSettle =
+			amount.gt(tokenAmountDeposited) && isolatedPositionUnrealizedPnl.gt(ZERO);
+		if (needsToSettle) {
+			const settleIx = await this.settleMultiplePNLsIx(
+				userAccountPublicKey,
+				userAccount,
+				[perpMarketIndex],
+				SettlePnlMode.TRY_SETTLE
+			);
+			ixs.push(settleIx);
+		}
+		return ixs;
+	}
+
+	public async getWithdrawFromIsolatedPerpPositionIx(
+		amount: BN,
+		perpMarketIndex: number,
+		userTokenAccount: PublicKey,
+		subAccountId?: number
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority,
+			subAccountId ?? this.activeSubAccountId
+		);
+		const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+		const spotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
+		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(subAccountId)],
+			writableSpotMarketIndexes: [spotMarketIndex],
+			readablePerpMarketIndex: [perpMarketIndex],
+		});
+
+		return await this.program.instruction.withdrawFromIsolatedPerpPosition(
+			spotMarketIndex,
+			perpMarketIndex,
+			amount,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					spotMarketVault: spotMarketAccount.vault,
+					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+					userTokenAccount: userTokenAccount,
+					tokenProgram: this.getTokenProgramForSpotMarket(spotMarketAccount),
+					driftSigner: this.getSignerPublicKey(),
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async updateSpotMarketCumulativeInterest(
 		marketIndex: number,
 		txParams?: TxParams
@@ -4199,7 +4510,6 @@ export class DriftClient {
 			}
 		);
 	}
-
 	public async getRemovePerpLpSharesIx(
 		marketIndex: number,
 		sharesToBurn?: BN,
@@ -4356,7 +4666,8 @@ export class DriftClient {
 		referrerInfo?: ReferrerInfo,
 		cancelExistingOrders?: boolean,
 		settlePnl?: boolean,
-		positionMaxLev?: number
+		positionMaxLev?: number,
+		isolatedPositionDepositAmount?: BN
 	): Promise<{
 		cancelExistingOrdersTx?: Transaction | VersionedTransaction;
 		settlePnlTx?: Transaction | VersionedTransaction;
@@ -4384,18 +4695,25 @@ export class DriftClient {
 
 		const txKeys = Object.keys(ixPromisesForTxs);
 
-		const marketOrderTxIxs = positionMaxLev
-			? this.getPlaceOrdersAndSetPositionMaxLevIx(
-					[orderParams, ...bracketOrdersParams],
-					positionMaxLev,
-					userAccount.subAccountId
-			  )
-			: this.getPlaceOrdersIx(
-					[orderParams, ...bracketOrdersParams],
-					userAccount.subAccountId
-			  );
+		const preIxs: TransactionInstruction[] = await this.getPrePlaceOrderIxs(
+			orderParams,
+			userAccount,
+			{
+				positionMaxLev,
+				isolatedPositionDepositAmount,
+			}
+		);
 
-		ixPromisesForTxs.marketOrderTx = marketOrderTxIxs;
+		ixPromisesForTxs.marketOrderTx = (async () => {
+			const placeOrdersIx = await this.getPlaceOrdersIx(
+				[orderParams, ...bracketOrdersParams],
+				userAccount.subAccountId
+			);
+			if (preIxs.length) {
+				return [...preIxs, placeOrdersIx] as unknown as TransactionInstruction;
+			}
+			return placeOrdersIx;
+		})();
 
 		/* Cancel open orders in market if requested */
 		if (cancelExistingOrders && isVariant(orderParams.marketType, 'perp')) {
@@ -4513,12 +4831,29 @@ export class DriftClient {
 	public async placePerpOrder(
 		orderParams: OptionalOrderParams,
 		txParams?: TxParams,
-		subAccountId?: number
+		subAccountId?: number,
+		isolatedPositionDepositAmount?: BN
 	): Promise<TransactionSignature> {
+		const preIxs: TransactionInstruction[] = [];
+		if (isolatedPositionDepositAmount?.gt?.(ZERO)) {
+			preIxs.push(
+				await this.getTransferIsolatedPerpPositionDepositIx(
+					isolatedPositionDepositAmount as BN,
+					orderParams.marketIndex,
+					subAccountId
+				)
+			);
+		}
+
 		const { txSig, slot } = await this.sendTransaction(
 			await this.buildTransaction(
 				await this.getPlacePerpOrderIx(orderParams, subAccountId),
-				txParams
+				txParams,
+				undefined,
+				undefined,
+				undefined,
+				undefined,
+				preIxs
 			),
 			[],
 			this.opts
@@ -4706,13 +5041,31 @@ export class DriftClient {
 	public async cancelOrder(
 		orderId?: number,
 		txParams?: TxParams,
-		subAccountId?: number
+		subAccountId?: number,
+		overrides?: { withdrawIsolatedDepositAmount?: BN }
 	): Promise<TransactionSignature> {
+		const cancelIx = await this.getCancelOrderIx(orderId, subAccountId);
+
+		const instructions: TransactionInstruction[] = [cancelIx];
+
+		if (overrides?.withdrawIsolatedDepositAmount !== undefined) {
+			const order = this.getOrder(orderId, subAccountId);
+			const perpMarketIndex = order?.marketIndex;
+			const withdrawAmount = overrides.withdrawIsolatedDepositAmount;
+
+			if (withdrawAmount.gt(ZERO)) {
+				const withdrawIxs =
+					await this.getWithdrawFromIsolatedPerpPositionIxsBundle(
+						withdrawAmount,
+						perpMarketIndex,
+						subAccountId
+					);
+				instructions.push(...withdrawIxs);
+			}
+		}
+
 		const { txSig } = await this.sendTransaction(
-			await this.buildTransaction(
-				await this.getCancelOrderIx(orderId, subAccountId),
-				txParams
-			),
+			await this.buildTransaction(instructions, txParams),
 			[],
 			this.opts
 		);
@@ -4946,7 +5299,8 @@ export class DriftClient {
 		params: OrderParams[],
 		txParams?: TxParams,
 		subAccountId?: number,
-		optionalIxs?: TransactionInstruction[]
+		optionalIxs?: TransactionInstruction[],
+		isolatedPositionDepositAmount?: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
 			(
@@ -4954,7 +5308,8 @@ export class DriftClient {
 					params,
 					txParams,
 					subAccountId,
-					optionalIxs
+					optionalIxs,
+					isolatedPositionDepositAmount
 				)
 			).placeOrdersTx,
 			[],
@@ -4968,10 +5323,28 @@ export class DriftClient {
 		params: OrderParams[],
 		txParams?: TxParams,
 		subAccountId?: number,
-		optionalIxs?: TransactionInstruction[]
+		optionalIxs?: TransactionInstruction[],
+		isolatedPositionDepositAmount?: BN
 	) {
 		const lookupTableAccounts = await this.fetchAllLookupTableAccounts();
 
+		const preIxs: TransactionInstruction[] = [];
+		if (params?.length === 1) {
+			const p = params[0];
+			if (
+				isVariant(p.marketType, 'perp') &&
+				isolatedPositionDepositAmount?.gt?.(ZERO)
+			) {
+				preIxs.push(
+					await this.getTransferIsolatedPerpPositionDepositIx(
+						isolatedPositionDepositAmount as BN,
+						p.marketIndex,
+						subAccountId
+					)
+				);
+			}
+		}
+
 		const tx = await this.buildTransaction(
 			await this.getPlaceOrdersIx(params, subAccountId),
 			txParams,
@@ -4979,14 +5352,13 @@ export class DriftClient {
 			lookupTableAccounts,
 			undefined,
 			undefined,
-			optionalIxs
+			[...preIxs, ...(optionalIxs ?? [])]
 		);
 
 		return {
 			placeOrdersTx: tx,
 		};
 	}
-
 	public async getPlaceOrdersIx(
 		params: OptionalOrderParams[],
 		subAccountId?: number,
@@ -5095,8 +5467,7 @@ export class DriftClient {
 		const marginRatio = Math.floor(
 			(1 / positionMaxLev) * MARGIN_PRECISION.toNumber()
 		);
-
-		// TODO: Handle multiple markets?
+		// Keep existing behavior but note: prefer using getPostPlaceOrderIxs path
 		const setPositionMaxLevIxs =
 			await this.getUpdateUserPerpPositionCustomMarginRatioIx(
 				readablePerpMarketIndex[0],
@@ -5753,6 +6124,7 @@ export class DriftClient {
 	/**
 	 * Swap tokens in drift account using titan or jupiter
 	 * @param swapClient swap client to find routes and instructions (Titan or Jupiter)
+	 * @param jupiterClient @deprecated Use swapClient instead. Legacy parameter for backward compatibility
 	 * @param outMarketIndex the market index of the token you're buying
 	 * @param inMarketIndex the market index of the token you're selling
 	 * @param outAssociatedTokenAccount the token account to receive the token being sold on titan or jupiter
@@ -5768,6 +6140,7 @@ export class DriftClient {
 	 */
 	public async swap({
 		swapClient,
+		jupiterClient,
 		outMarketIndex,
 		inMarketIndex,
 		outAssociatedTokenAccount,
@@ -5781,7 +6154,9 @@ export class DriftClient {
 		quote,
 		onlyDirectRoutes = false,
 	}: {
-		swapClient: UnifiedSwapClient | SwapClient;
+		swapClient?: UnifiedSwapClient | SwapClient;
+		/** @deprecated Use swapClient instead. Legacy parameter for backward compatibility */
+		jupiterClient?: JupiterClient;
 		outMarketIndex: number;
 		inMarketIndex: number;
 		outAssociatedTokenAccount?: PublicKey;
@@ -5797,15 +6172,22 @@ export class DriftClient {
 		};
 		quote?: QuoteResponse;
 	}): Promise<TransactionSignature> {
+		// Handle backward compatibility: use jupiterClient if swapClient is not provided
+		const clientToUse = swapClient || jupiterClient;
+
+		if (!clientToUse) {
+			throw new Error('Either swapClient or jupiterClient must be provided');
+		}
+
 		let res: {
 			ixs: TransactionInstruction[];
 			lookupTables: AddressLookupTableAccount[];
 		};
 
 		// Use unified SwapClient if available
-		if (swapClient instanceof UnifiedSwapClient) {
+		if (clientToUse instanceof UnifiedSwapClient) {
 			res = await this.getSwapIxV2({
-				swapClient,
+				swapClient: clientToUse,
 				outMarketIndex,
 				inMarketIndex,
 				outAssociatedTokenAccount,
@@ -5818,9 +6200,9 @@ export class DriftClient {
 				quote,
 				v6,
 			});
-		} else if (swapClient instanceof TitanClient) {
+		} else if (clientToUse instanceof TitanClient) {
 			res = await this.getTitanSwapIx({
-				titanClient: swapClient,
+				titanClient: clientToUse,
 				outMarketIndex,
 				inMarketIndex,
 				outAssociatedTokenAccount,
@@ -5831,10 +6213,10 @@ export class DriftClient {
 				onlyDirectRoutes,
 				reduceOnly,
 			});
-		} else if (swapClient instanceof JupiterClient) {
+		} else if (clientToUse instanceof JupiterClient) {
 			const quoteToUse = quote ?? v6?.quote;
 			res = await this.getJupiterSwapIxV6({
-				jupiterClient: swapClient,
+				jupiterClient: clientToUse,
 				outMarketIndex,
 				inMarketIndex,
 				outAssociatedTokenAccount,
@@ -6786,7 +7168,6 @@ export class DriftClient {
 		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
 		return txSig;
 	}
-
 	public async preparePlaceAndTakePerpOrderWithAdditionalOrders(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],
@@ -6798,7 +7179,8 @@ export class DriftClient {
 		settlePnl?: boolean,
 		exitEarlyIfSimFails?: boolean,
 		auctionDurationPercentage?: number,
-		optionalIxs?: TransactionInstruction[]
+		optionalIxs?: TransactionInstruction[],
+		isolatedPositionDepositAmount?: BN
 	): Promise<{
 		placeAndTakeTx: Transaction | VersionedTransaction;
 		cancelExistingOrdersTx: Transaction | VersionedTransaction;
@@ -6832,6 +7214,19 @@ export class DriftClient {
 				subAccountId
 			);
 
+			if (
+				isVariant(orderParams.marketType, 'perp') &&
+				isolatedPositionDepositAmount?.gt?.(ZERO)
+			) {
+				placeAndTakeIxs.push(
+					await this.getTransferIsolatedPerpPositionDepositIx(
+						isolatedPositionDepositAmount as BN,
+						orderParams.marketIndex,
+						subAccountId
+					)
+				);
+			}
+
 			placeAndTakeIxs.push(placeAndTakeIx);
 
 			if (bracketOrdersParams.length > 0) {
@@ -6842,6 +7237,11 @@ export class DriftClient {
 				placeAndTakeIxs.push(bracketOrdersIx);
 			}
 
+			// Optional extra ixs can be appended at the front
+			if (optionalIxs?.length) {
+				placeAndTakeIxs.unshift(...optionalIxs);
+			}
+
 			const shouldUseSimulationComputeUnits =
 				txParams?.useSimulatedComputeUnits;
 			const shouldExitIfSimulationFails = exitEarlyIfSimFails;
@@ -7649,7 +8049,6 @@ export class DriftClient {
 		this.spotMarketLastSlotCache.set(QUOTE_SPOT_MARKET_INDEX, slot);
 		return txSig;
 	}
-
 	public async getPlaceAndTakeSpotOrderIx(
 		orderParams: OptionalOrderParams,
 		fulfillmentConfig?: SerumV3FulfillmentConfigAccount,
@@ -8112,7 +8511,6 @@ export class DriftClient {
 			bitFlags?: number;
 			policy?: ModifyOrderPolicy;
 			maxTs?: BN;
-			txParams?: TxParams;
 		},
 		subAccountId?: number
 	): Promise<TransactionInstruction> {
@@ -8638,7 +9036,6 @@ export class DriftClient {
 		this.perpMarketLastSlotCache.set(marketIndex, slot);
 		return txSig;
 	}
-
 	public async getLiquidatePerpIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
@@ -9429,7 +9826,6 @@ export class DriftClient {
 			}
 		);
 	}
-
 	public async resolveSpotBankruptcy(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
@@ -10266,7 +10662,6 @@ export class DriftClient {
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 		return txSig;
 	}
-
 	public async getSettleRevenueToInsuranceFundIx(
 		spotMarketIndex: number
 	): Promise<TransactionInstruction> {
@@ -11061,7 +11456,6 @@ export class DriftClient {
 		);
 		return config as ProtectedMakerModeConfig;
 	}
-
 	public async updateUserProtectedMakerOrders(
 		subAccountId: number,
 		protectedOrders: boolean,
@@ -12455,4 +12849,23 @@ export class DriftClient {
 			forceVersionedTransaction,
 		});
 	}
+
+	isOrderIncreasingPosition(
+		orderParams: OptionalOrderParams,
+		userAccount: UserAccount
+	): boolean {
+		const perpPosition = userAccount.perpPositions.find(
+			(p) => p.marketIndex === orderParams.marketIndex
+		);
+		if (!perpPosition) return true;
+
+		const currentBase = perpPosition.baseAssetAmount;
+		if (currentBase.eq(ZERO)) return true;
+
+		const orderBaseAmount = isVariant(orderParams.direction, 'long')
+			? orderParams.baseAssetAmount
+			: orderParams.baseAssetAmount.neg();
+
+		return currentBase.add(orderBaseAmount).abs().gt(currentBase.abs());
+	}
 }