@drift-labs/sdk 2.149.0-beta.8 → 2.150.0-alpha.0

package/.env

@@ -0,0 +1,4 @@
+# GRPC_ENDPOINT=https://drift-drift-951a.mainnet.rpcpool.com
+# TOKEN=f1ead98714b94a67f82203cce918
+GRPC_ENDPOINT=https://laserstream-mainnet-ams.helius-rpc.com
+TOKEN=ff40c844-e15b-49d0-9d62-8534705aa48b

package/VERSION

@@ -1 +1 @@
-2.149.0-beta.8
+2.150.0-alpha.0

package/lib/browser/constants/perpMarkets.js

@@ -1327,6 +1327,17 @@ exports.MainnetPerpMarkets = [
         oracleSource: types_1.OracleSource.PYTH_LAZER,
         pythLazerId: 2382,
     },
+    {
+        fullName: 'Monad',
+        category: ['L1'],
+        symbol: '1KMON-PERP',
+        baseAssetSymbol: '1KMON',
+        marketIndex: 83,
+        oracle: new web3_js_1.PublicKey('585jsthKg9BeTfnFGAxgfNie9krGGyPbd5feMpWneHf7'),
+        launchTs: 1763996757000,
+        oracleSource: types_1.OracleSource.PYTH_LAZER_1K,
+        pythLazerId: 2396,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/browser/constants/spotMarkets.js

@@ -869,6 +869,19 @@ exports.MainnetSpotMarkets = [
         pythLazerId: 2382,
         launchTs: 1761225524000,
     },
+    {
+        symbol: 'CASH',
+        marketIndex: 61,
+        poolId: 0,
+        oracle: new web3_js_1.PublicKey('AK6coxSjfAnuDT4ZUSP3UpeQe2G1tKcALnsdd835eg7T'),
+        oracleSource: types_1.OracleSource.PYTH_LAZER_STABLE_COIN,
+        mint: new web3_js_1.PublicKey('CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH'),
+        precision: new anchor_1.BN(10).pow(numericConstants_1.SIX),
+        precisionExp: numericConstants_1.SIX,
+        pythFeedId: '0xdf3320ef0f4617337b8dbb924f2aaa4f9db08f522a5435b44f9066c1ac4c7f95',
+        pythLazerId: 2323,
+        launchTs: 1763677264000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/browser/decode/user.js

@@ -71,7 +71,7 @@ function decodeUser(buffer) {
         const quoteAssetAmount = readSignedBigInt64LE(buffer, offset + 16);
         const lpShares = readUnsignedBigInt64LE(buffer, offset + 64);
         const openOrders = buffer.readUInt8(offset + 94);
-        const positionFlag = buffer.readUInt8(offset + 95);
+        const positionFlag = 0;
         const isolatedPositionScaledBalance = readUnsignedBigInt64LE(buffer, offset + 96);
         if (baseAssetAmount.eq(numericConstants_1.ZERO) &&
             openOrders === 0 &&
@@ -119,8 +119,8 @@ function decodeUser(buffer) {
             openOrders,
             perLpBase,
             maxMarginRatio,
-            isolatedPositionScaledBalance,
             positionFlag,
+            isolatedPositionScaledBalance,
         });
     }
     const orders = [];

package/lib/browser/driftClient.d.ts

@@ -5,7 +5,7 @@
 import * as anchor from '@coral-xyz/anchor';
 import { AnchorProvider, BN, Program, ProgramAccount } from '@coral-xyz/anchor';
 import { Idl as Idl30, Program as Program30 } from '@coral-xyz/anchor-30';
-import { DriftClientMetricsEvents, HighLeverageModeConfig, IWallet, MakerInfo, MappedRecord, MarketType, ModifyOrderPolicy, OpenbookV2FulfillmentConfigAccount, OptionalOrderParams, OracleSource, Order, OrderParams, OrderTriggerCondition, PerpMarketAccount, PerpMarketExtendedInfo, PhoenixV1FulfillmentConfigAccount, PlaceAndTakeOrderSuccessCondition, PositionDirection, ReferrerInfo, ReferrerNameAccount, SerumV3FulfillmentConfigAccount, SettlePnlMode, SignedTxData, SpotMarketAccount, SpotPosition, StateAccount, SwapReduceOnly, SignedMsgOrderParamsMessage, TakerInfo, TxParams, UserAccount, UserStatsAccount, ProtectedMakerModeConfig, SignedMsgOrderParamsDelegateMessage, PostOnlyParams, LPPoolAccount, ConstituentAccount, ConstituentTargetBaseAccount, AmmCache } from './types';
+import { DriftClientMetricsEvents, HighLeverageModeConfig, IWallet, MakerInfo, MappedRecord, MarketType, ModifyOrderPolicy, OpenbookV2FulfillmentConfigAccount, OptionalOrderParams, OracleSource, Order, OrderParams, OrderTriggerCondition, PerpMarketAccount, PerpMarketExtendedInfo, PhoenixV1FulfillmentConfigAccount, PlaceAndTakeOrderSuccessCondition, PositionDirection, ReferrerInfo, ReferrerNameAccount, SerumV3FulfillmentConfigAccount, SettlePnlMode, SignedTxData, SpotMarketAccount, SpotPosition, StateAccount, SwapReduceOnly, SignedMsgOrderParamsMessage, TxParams, UserAccount, UserStatsAccount, ProtectedMakerModeConfig, SignedMsgOrderParamsDelegateMessage, PostOnlyParams, LPPoolAccount, ConstituentAccount, ConstituentTargetBaseAccount, AmmCache } from './types';
 import { AccountMeta, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, ConfirmOptions, Connection, Keypair, PublicKey, Signer, Transaction, TransactionInstruction, TransactionSignature, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
@@ -26,6 +26,7 @@ import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/
 import { PythSolanaReceiver } from '@pythnetwork/pyth-solana-receiver/lib/idl/pyth_solana_receiver';
 import { Slothash } from './slot/SlothashSubscriber';
 import { SignedMsgOrderParams } from './types';
+import { TakerInfo } from './types';
 import { ConstituentMap } from './constituentMap/constituentMap';
 import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 import { TitanClient } from './titan/titanClient';
@@ -89,6 +90,7 @@ export declare class DriftClient {
     sbOnDemandProgram?: Program30<Idl30>;
     sbProgramFeedConfigs?: Map<string, any>;
     get isSubscribed(): boolean;
+    private getPrePlaceOrderIxs;
     set isSubscribed(val: boolean);
     constructor(config: DriftClientConfig);
     getUserMapKey(subAccountId: number, authority: PublicKey): string;
@@ -306,6 +308,7 @@ export declare class DriftClient {
     getUserAccountAndSlot(subAccountId?: number, authority?: PublicKey): DataAndSlot<UserAccount> | undefined;
     getSpotPosition(marketIndex: number, subAccountId?: number): SpotPosition | undefined;
     getQuoteAssetTokenAmount(): BN;
+    getIsolatedPerpPositionTokenAmount(perpMarketIndex: number, subAccountId?: number): BN;
     /**
      * 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.
@@ -450,6 +453,13 @@ export declare class DriftClient {
     getTransferPoolsIx(depositFromMarketIndex: number, depositToMarketIndex: number, borrowFromMarketIndex: number, borrowToMarketIndex: number, depositAmount: BN | undefined, borrowAmount: BN | undefined, fromSubAccountId: number, toSubAccountId: number, isToNewSubAccount?: boolean): Promise<TransactionInstruction>;
     transferPerpPosition(fromSubAccountId: number, toSubAccountId: number, marketIndex: number, amount: BN, txParams?: TxParams): Promise<TransactionSignature>;
     getTransferPerpPositionIx(fromSubAccountId: number, toSubAccountId: number, marketIndex: number, amount: BN): Promise<TransactionInstruction>;
+    depositIntoIsolatedPerpPosition(amount: BN, perpMarketIndex: number, userTokenAccount: PublicKey, subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getDepositIntoIsolatedPerpPositionIx(amount: BN, perpMarketIndex: number, userTokenAccount: PublicKey, subAccountId?: number): Promise<TransactionInstruction>;
+    transferIsolatedPerpPositionDeposit(amount: BN, perpMarketIndex: number, subAccountId?: number, txParams?: TxParams, trySettle?: boolean): Promise<TransactionSignature>;
+    getTransferIsolatedPerpPositionDepositIx(amount: BN, perpMarketIndex: number, subAccountId?: number, noAmountBuffer?: boolean): Promise<TransactionInstruction>;
+    withdrawFromIsolatedPerpPosition(amount: BN, perpMarketIndex: number, userTokenAccount: PublicKey, subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getWithdrawFromIsolatedPerpPositionIxsBundle(amount: BN, perpMarketIndex: number, subAccountId?: number, userTokenAccount?: PublicKey): Promise<TransactionInstruction[]>;
+    getWithdrawFromIsolatedPerpPositionIx(amount: BN, perpMarketIndex: number, userTokenAccount: PublicKey, subAccountId?: number): Promise<TransactionInstruction>;
     updateSpotMarketCumulativeInterest(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     updateSpotMarketCumulativeInterestIx(marketIndex: number): Promise<TransactionInstruction>;
     settleLP(settleeUserAccountPublicKey: PublicKey, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
@@ -466,7 +476,7 @@ export declare class DriftClient {
      */
     openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN, subAccountId?: number): Promise<TransactionSignature>;
     sendSignedTx(tx: Transaction | VersionedTransaction, opts?: ConfirmOptions): Promise<TransactionSignature>;
-    prepareMarketOrderTxs(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean, positionMaxLev?: number): Promise<{
+    prepareMarketOrderTxs(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean, positionMaxLev?: number, isolatedPositionDepositAmount?: BN): Promise<{
         cancelExistingOrdersTx?: Transaction | VersionedTransaction;
         settlePnlTx?: Transaction | VersionedTransaction;
         fillTx?: Transaction | VersionedTransaction;
@@ -489,7 +499,7 @@ export declare class DriftClient {
         signedCancelExistingOrdersTx?: Transaction;
         signedSettlePnlTx?: Transaction;
     }>;
-    placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number, isolatedPositionDepositAmount?: BN): Promise<TransactionSignature>;
     getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number, depositToTradeArgs?: {
         isMakingNewAccount: boolean;
         depositMarketIndex: number;
@@ -500,7 +510,9 @@ export declare class DriftClient {
     getSettleExpiredMarketIx(marketIndex: number): Promise<TransactionInstruction>;
     settleExpiredMarketPoolsToRevenuePool(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getSettleExpiredMarketPoolsToRevenuePoolIx(perpMarketIndex: number): Promise<TransactionInstruction>;
-    cancelOrder(orderId?: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    cancelOrder(orderId?: number, txParams?: TxParams, subAccountId?: number, overrides?: {
+        withdrawIsolatedDepositAmount?: BN;
+    }): Promise<TransactionSignature>;
     getCancelOrderIx(orderId?: number, subAccountId?: number): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number, subAccountId?: number): Promise<TransactionInstruction>;
@@ -534,8 +546,8 @@ export declare class DriftClient {
         marketIndex?: number;
         direction?: PositionDirection;
     }, placeOrderParams: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number, optionalIxs?: TransactionInstruction[]): Promise<TransactionSignature>;
-    preparePlaceOrdersTx(params: OrderParams[], txParams?: TxParams, subAccountId?: number, optionalIxs?: TransactionInstruction[]): Promise<{
+    placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number, optionalIxs?: TransactionInstruction[], isolatedPositionDepositAmount?: BN): Promise<TransactionSignature>;
+    preparePlaceOrdersTx(params: OrderParams[], txParams?: TxParams, subAccountId?: number, optionalIxs?: TransactionInstruction[], isolatedPositionDepositAmount?: BN): Promise<{
         placeOrdersTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
     }>;
     getPlaceOrdersIx(params: OptionalOrderParams[], subAccountId?: number, overrides?: {
@@ -692,7 +704,7 @@ export declare class DriftClient {
     updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
     getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean, auctionDurationPercentage?: number, optionalIxs?: TransactionInstruction[]): Promise<{
+    preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean, auctionDurationPercentage?: number, optionalIxs?: TransactionInstruction[], isolatedPositionDepositAmount?: BN): Promise<{
         placeAndTakeTx: Transaction | VersionedTransaction;
         cancelExistingOrdersTx: Transaction | VersionedTransaction;
         settlePnlTx: Transaction | VersionedTransaction;
@@ -891,7 +903,6 @@ export declare class DriftClient {
         bitFlags?: number;
         policy?: ModifyOrderPolicy;
         maxTs?: BN;
-        txParams?: TxParams;
     }, subAccountId?: number): Promise<TransactionInstruction>;
     settlePNLs(users: {
         settleeUserAccountPublicKey: PublicKey;
@@ -1232,5 +1243,6 @@ export declare class DriftClient {
         signedTxMap: MappedRecord<Record<string, anchor.web3.TransactionInstruction | anchor.web3.TransactionInstruction[]>, anchor.web3.Transaction | anchor.web3.VersionedTransaction>;
         signedTxData: SignedTxData[];
     }>;
+    isOrderIncreasingPosition(orderParams: OptionalOrderParams, subAccountId: number): boolean;
 }
 export {};

package/lib/browser/driftClient.js

@@ -71,6 +71,7 @@ const on_demand_1 = require("@switchboard-xyz/on-demand");
 const grpcDriftClientAccountSubscriber_1 = require("./accounts/grpcDriftClientAccountSubscriber");
 const tweetnacl_1 = __importDefault(require("tweetnacl"));
 const oracleId_1 = require("./oracles/oracleId");
+// BN is already imported globally in this file via other imports
 const sha256_1 = require("@noble/hashes/sha256");
 const utils_3 = require("./oracles/utils");
 const orders_1 = require("./math/orders");
@@ -85,6 +86,22 @@ class DriftClient {
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
     }
+    async getPrePlaceOrderIxs(orderParams, userAccount, options) {
+        var _a;
+        const preIxs = [];
+        if ((0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            const { positionMaxLev, isolatedPositionDepositAmount } = options !== null && options !== void 0 ? options : {};
+            if (((_a = isolatedPositionDepositAmount === null || isolatedPositionDepositAmount === void 0 ? void 0 : isolatedPositionDepositAmount.gt) === null || _a === void 0 ? void 0 : _a.call(isolatedPositionDepositAmount, numericConstants_1.ZERO)) &&
+                this.isOrderIncreasingPosition(orderParams, userAccount.subAccountId)) {
+                preIxs.push(await this.getTransferIsolatedPerpPositionDepositIx(isolatedPositionDepositAmount, orderParams.marketIndex, userAccount.subAccountId));
+            }
+            if (positionMaxLev) {
+                const marginRatio = Math.floor((1 / positionMaxLev) * numericConstants_1.MARGIN_PRECISION.toNumber());
+                preIxs.push(await this.getUpdateUserPerpPositionCustomMarginRatioIx(orderParams.marketIndex, marginRatio, userAccount.subAccountId));
+            }
+        }
+        return preIxs;
+    }
     set isSubscribed(val) {
         this._isSubscribed = val;
     }
@@ -1382,6 +1399,9 @@ class DriftClient {
     getQuoteAssetTokenAmount() {
         return this.getTokenAmount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
     }
+    getIsolatedPerpPositionTokenAmount(perpMarketIndex, subAccountId) {
+        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.
@@ -2139,6 +2159,129 @@ class DriftClient {
             remainingAccounts,
         });
     }
+    async depositIntoIsolatedPerpPosition(amount, perpMarketIndex, userTokenAccount, subAccountId, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getDepositIntoIsolatedPerpPositionIx(amount, perpMarketIndex, userTokenAccount, subAccountId), txParams), [], this.opts);
+        return txSig;
+    }
+    async getDepositIntoIsolatedPerpPositionIx(amount, perpMarketIndex, userTokenAccount, subAccountId) {
+        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId !== null && subAccountId !== void 0 ? 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,
+        });
+    }
+    async transferIsolatedPerpPositionDeposit(amount, perpMarketIndex, subAccountId, txParams, trySettle) {
+        const ixs = [];
+        const tokenAmountDeposited = this.getIsolatedPerpPositionTokenAmount(perpMarketIndex);
+        const transferIx = await this.getTransferIsolatedPerpPositionDepositIx(amount, perpMarketIndex, subAccountId);
+        const needsToSettle = amount.gt(tokenAmountDeposited) || amount.eq(numericConstants_1.MIN_I64) || trySettle;
+        if (needsToSettle) {
+            const settleIx = await this.settleMultiplePNLsIx(await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId !== null && subAccountId !== void 0 ? subAccountId : this.activeSubAccountId), this.getUserAccount(subAccountId), [perpMarketIndex], types_1.SettlePnlMode.TRY_SETTLE);
+            ixs.push(settleIx);
+        }
+        ixs.push(transferIx);
+        const tx = await this.buildTransaction(ixs, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], {
+            ...this.opts,
+            skipPreflight: true,
+        });
+        return txSig;
+    }
+    async getTransferIsolatedPerpPositionDepositIx(amount, perpMarketIndex, subAccountId, noAmountBuffer) {
+        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId !== null && subAccountId !== void 0 ? 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(numericConstants_1.MIN_I64)
+            ? amount
+            : amount.add(amount.div(new anchor_1.BN(200))); // .5% 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,
+        });
+    }
+    async withdrawFromIsolatedPerpPosition(amount, perpMarketIndex, userTokenAccount, subAccountId, txParams) {
+        const instructions = await this.getWithdrawFromIsolatedPerpPositionIxsBundle(amount, perpMarketIndex, subAccountId, userTokenAccount);
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(instructions, txParams));
+        return txSig;
+    }
+    async getWithdrawFromIsolatedPerpPositionIxsBundle(amount, perpMarketIndex, subAccountId, userTokenAccount) {
+        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId !== null && subAccountId !== void 0 ? subAccountId : this.activeSubAccountId);
+        const userAccount = this.getUserAccount(subAccountId);
+        const tokenAmountDeposited = this.getIsolatedPerpPositionTokenAmount(perpMarketIndex);
+        const isolatedPositionUnrealizedPnl = (0, position_1.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)
+            ? numericConstants_1.MIN_I64 // min i64
+            : amount;
+        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(numericConstants_1.ZERO);
+        if (needsToSettle) {
+            const settleIx = await this.settleMultiplePNLsIx(userAccountPublicKey, userAccount, [perpMarketIndex], types_1.SettlePnlMode.TRY_SETTLE);
+            ixs.push(settleIx);
+        }
+        return ixs;
+    }
+    async getWithdrawFromIsolatedPerpPositionIx(amount, perpMarketIndex, userTokenAccount, subAccountId) {
+        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId !== null && subAccountId !== void 0 ? 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,
+        });
+    }
     async updateSpotMarketCumulativeInterest(marketIndex, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.updateSpotMarketCumulativeInterestIx(marketIndex), txParams), [], this.opts);
         return txSig;
@@ -2271,7 +2414,7 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, undefined, opts !== null && opts !== void 0 ? opts : this.opts, true);
         return txSig;
     }
-    async prepareMarketOrderTxs(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders, settlePnl, positionMaxLev) {
+    async prepareMarketOrderTxs(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders, settlePnl, positionMaxLev, isolatedPositionDepositAmount) {
         const marketIndex = orderParams.marketIndex;
         const orderId = userAccount.nextOrderId;
         const ixPromisesForTxs = {
@@ -2281,10 +2424,17 @@ class DriftClient {
             marketOrderTx: undefined,
         };
         const txKeys = Object.keys(ixPromisesForTxs);
-        const marketOrderTxIxs = positionMaxLev
-            ? this.getPlaceOrdersAndSetPositionMaxLevIx([orderParams, ...bracketOrdersParams], positionMaxLev, userAccount.subAccountId)
-            : this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
-        ixPromisesForTxs.marketOrderTx = marketOrderTxIxs;
+        const preIxs = await this.getPrePlaceOrderIxs(orderParams, userAccount, {
+            positionMaxLev,
+            isolatedPositionDepositAmount,
+        });
+        ixPromisesForTxs.marketOrderTx = (async () => {
+            const placeOrdersIx = await this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
+            if (preIxs.length) {
+                return [...preIxs, placeOrdersIx];
+            }
+            return placeOrdersIx;
+        })();
         /* Cancel open orders in market if requested */
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
             ixPromisesForTxs.cancelExistingOrdersTx = this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
@@ -2331,8 +2481,14 @@ class DriftClient {
             signedSettlePnlTx: signedTxs.settlePnlTx,
         };
     }
-    async placePerpOrder(orderParams, txParams, subAccountId) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlacePerpOrderIx(orderParams, subAccountId), txParams), [], this.opts);
+    async placePerpOrder(orderParams, txParams, subAccountId, isolatedPositionDepositAmount) {
+        var _a;
+        const preIxs = [];
+        if (((_a = isolatedPositionDepositAmount === null || isolatedPositionDepositAmount === void 0 ? void 0 : isolatedPositionDepositAmount.gt) === null || _a === void 0 ? void 0 : _a.call(isolatedPositionDepositAmount, numericConstants_1.ZERO)) &&
+            this.isOrderIncreasingPosition(orderParams, subAccountId)) {
+            preIxs.push(await this.getTransferIsolatedPerpPositionDepositIx(isolatedPositionDepositAmount, orderParams.marketIndex, subAccountId));
+        }
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlacePerpOrderIx(orderParams, subAccountId), txParams, undefined, undefined, undefined, undefined, preIxs), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
@@ -2438,8 +2594,19 @@ class DriftClient {
             },
         });
     }
-    async cancelOrder(orderId, txParams, subAccountId) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrderIx(orderId, subAccountId), txParams), [], this.opts);
+    async cancelOrder(orderId, txParams, subAccountId, overrides) {
+        const cancelIx = await this.getCancelOrderIx(orderId, subAccountId);
+        const instructions = [cancelIx];
+        if ((overrides === null || overrides === void 0 ? void 0 : overrides.withdrawIsolatedDepositAmount) !== undefined) {
+            const order = this.getOrder(orderId, subAccountId);
+            const perpMarketIndex = order === null || order === void 0 ? void 0 : order.marketIndex;
+            const withdrawAmount = overrides.withdrawIsolatedDepositAmount;
+            if (withdrawAmount.gt(numericConstants_1.ZERO)) {
+                const withdrawIxs = await this.getWithdrawFromIsolatedPerpPositionIxsBundle(withdrawAmount, perpMarketIndex, subAccountId);
+                instructions.push(...withdrawIxs);
+            }
+        }
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(instructions, txParams), [], this.opts);
         return txSig;
     }
     async getCancelOrderIx(orderId, subAccountId) {
@@ -2558,13 +2725,23 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async placeOrders(params, txParams, subAccountId, optionalIxs) {
-        const { txSig } = await this.sendTransaction((await this.preparePlaceOrdersTx(params, txParams, subAccountId, optionalIxs)).placeOrdersTx, [], this.opts, false);
+    async placeOrders(params, txParams, subAccountId, optionalIxs, isolatedPositionDepositAmount) {
+        const { txSig } = await this.sendTransaction((await this.preparePlaceOrdersTx(params, txParams, subAccountId, optionalIxs, isolatedPositionDepositAmount)).placeOrdersTx, [], this.opts, false);
         return txSig;
     }
-    async preparePlaceOrdersTx(params, txParams, subAccountId, optionalIxs) {
+    async preparePlaceOrdersTx(params, txParams, subAccountId, optionalIxs, isolatedPositionDepositAmount) {
+        var _a;
         const lookupTableAccounts = await this.fetchAllLookupTableAccounts();
-        const tx = await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams, undefined, lookupTableAccounts, undefined, undefined, optionalIxs);
+        const preIxs = [];
+        if ((params === null || params === void 0 ? void 0 : params.length) === 1) {
+            const p = params[0];
+            if ((0, types_1.isVariant)(p.marketType, 'perp') &&
+                ((_a = isolatedPositionDepositAmount === null || isolatedPositionDepositAmount === void 0 ? void 0 : isolatedPositionDepositAmount.gt) === null || _a === void 0 ? void 0 : _a.call(isolatedPositionDepositAmount, numericConstants_1.ZERO)) &&
+                this.isOrderIncreasingPosition(p, subAccountId)) {
+                preIxs.push(await this.getTransferIsolatedPerpPositionDepositIx(isolatedPositionDepositAmount, p.marketIndex, subAccountId));
+            }
+        }
+        const tx = await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams, undefined, lookupTableAccounts, undefined, undefined, [...preIxs, ...(optionalIxs !== null && optionalIxs !== void 0 ? optionalIxs : [])]);
         return {
             placeOrdersTx: tx,
         };
@@ -2653,7 +2830,7 @@ class DriftClient {
             remainingAccounts,
         });
         const marginRatio = Math.floor((1 / positionMaxLev) * numericConstants_1.MARGIN_PRECISION.toNumber());
-        // TODO: Handle multiple markets?
+        // Keep existing behavior but note: prefer using getPostPlaceOrderIxs path
         const setPositionMaxLevIxs = await this.getUpdateUserPerpPositionCustomMarginRatioIx(readablePerpMarketIndex[0], marginRatio, subAccountId);
         return [placeOrdersIxs, setPositionMaxLevIxs];
     }
@@ -3654,7 +3831,7 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails, auctionDurationPercentage, optionalIxs) {
+    async preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails, auctionDurationPercentage, optionalIxs, isolatedPositionDepositAmount) {
         const placeAndTakeIxs = [];
         const txsToSign = {
             placeAndTakeTx: undefined,
@@ -3666,13 +3843,22 @@ class DriftClient {
         const lookupTableAccounts = await this.fetchAllLookupTableAccounts();
         let earlyExitFailedPlaceAndTakeSim = false;
         const prepPlaceAndTakeTx = async () => {
-            var _a;
+            var _a, _b;
             const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, undefined, auctionDurationPercentage, subAccountId);
+            if ((0, types_1.isVariant)(orderParams.marketType, 'perp') &&
+                ((_a = isolatedPositionDepositAmount === null || isolatedPositionDepositAmount === void 0 ? void 0 : isolatedPositionDepositAmount.gt) === null || _a === void 0 ? void 0 : _a.call(isolatedPositionDepositAmount, numericConstants_1.ZERO)) &&
+                this.isOrderIncreasingPosition(orderParams, subAccountId)) {
+                placeAndTakeIxs.push(await this.getTransferIsolatedPerpPositionDepositIx(isolatedPositionDepositAmount, orderParams.marketIndex, subAccountId));
+            }
             placeAndTakeIxs.push(placeAndTakeIx);
             if (bracketOrdersParams.length > 0) {
                 const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
                 placeAndTakeIxs.push(bracketOrdersIx);
             }
+            // Optional extra ixs can be appended at the front
+            if (optionalIxs === null || optionalIxs === void 0 ? void 0 : optionalIxs.length) {
+                placeAndTakeIxs.unshift(...optionalIxs);
+            }
             const shouldUseSimulationComputeUnits = txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits;
             const shouldExitIfSimulationFails = exitEarlyIfSimFails;
             const txParamsWithoutImplicitSimulation = {
@@ -3681,7 +3867,7 @@ class DriftClient {
             };
             if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
                 const placeAndTakeTxToSim = (await this.buildTransaction(placeAndTakeIxs, txParams, undefined, lookupTableAccounts, true, recentBlockHash, optionalIxs));
-                const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_a = txParams.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : 1.2, txParams.lowerBoundCu);
+                const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_b = txParams.computeUnitsBufferMultiplier) !== null && _b !== void 0 ? _b : 1.2, txParams.lowerBoundCu);
                 if (shouldExitIfSimulationFails && !simulationResult.success) {
                     earlyExitFailedPlaceAndTakeSim = true;
                     return;
@@ -6486,5 +6672,18 @@ class DriftClient {
             forceVersionedTransaction,
         });
     }
+    isOrderIncreasingPosition(orderParams, subAccountId) {
+        const userAccount = this.getUserAccount(subAccountId);
+        const perpPosition = userAccount.perpPositions.find((p) => p.marketIndex === orderParams.marketIndex);
+        if (!perpPosition)
+            return true;
+        const currentBase = perpPosition.baseAssetAmount;
+        if (currentBase.eq(numericConstants_1.ZERO))
+            return true;
+        const orderBaseAmount = (0, types_1.isVariant)(orderParams.direction, 'long')
+            ? orderParams.baseAssetAmount
+            : orderParams.baseAssetAmount.neg();
+        return currentBase.add(orderBaseAmount).abs().gt(currentBase.abs());
+    }
 }
 exports.DriftClient = DriftClient;