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

package/src/driftClient.ts

@@ -95,6 +95,7 @@ import {
 	PRICE_PRECISION,
 	QUOTE_SPOT_MARKET_INDEX,
 	ZERO,
+	QUOTE_PRECISION,
 } from './constants/numericConstants';
 import { findDirectionToClose, positionIsAvailable } from './math/position';
 import { getSignedTokenAmount, getTokenAmount } from './math/spotBalance';
@@ -115,12 +116,14 @@ import { fetchUserStatsAccount } from './accounts/fetch';
 import { castNumberToSpotPrecision } from './math/spotMarket';
 import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
 import { getNonIdleUserFilter } from './memcmp';
+import { UserStatsSubscriptionConfig } from './userStatsConfig';
+import { getMarinadeDepositIx, getMarinadeFinanceProgram } from './marinade';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
 	writablePerpMarketIndexes?: number[];
 	writableSpotMarketIndexes?: number[];
-	readablePerpMarketIndex?: number;
+	readablePerpMarketIndex?: number | number[];
 	readableSpotMarketIndexes?: number[];
 	useMarketLastSlotCache?: boolean;
 };
@@ -139,12 +142,15 @@ export class DriftClient {
 	userStats?: UserStats;
 	activeSubAccountId: number;
 	userAccountSubscriptionConfig: UserSubscriptionConfig;
+	userStatsAccountSubscriptionConfig: UserStatsSubscriptionConfig;
 	accountSubscriber: DriftClientAccountSubscriber;
 	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
 	_isSubscribed = false;
 	txSender: TxSender;
 	perpMarketLastSlotCache = new Map<number, number>();
 	spotMarketLastSlotCache = new Map<number, number>();
+	mustIncludePerpMarketIndexes = new Set<number>();
+	mustIncludeSpotMarketIndexes = new Set<number>();
 	authority: PublicKey;
 	marketLookupTable: PublicKey;
 	lookupTableAccount: AddressLookupTableAccount;
@@ -152,6 +158,7 @@ export class DriftClient {
 	authoritySubAccountMap?: Map<string, number[]>;
 	skipLoadUsers?: boolean;
 	txVersion: TransactionVersion;
+	txParams: TxParams;
 
 	public get isSubscribed() {
 		return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -180,6 +187,10 @@ export class DriftClient {
 		this.activeSubAccountId = config.activeSubAccountId ?? 0;
 		this.skipLoadUsers = config.skipLoadUsers ?? false;
 		this.txVersion = config.txVersion ?? 'legacy';
+		this.txParams = {
+			computeUnits: config.txParams?.computeUnits ?? 600_000,
+			computeUnitsPrice: config.txParams?.computeUnitsPrice ?? 0,
+		};
 
 		if (config.includeDelegates && config.subAccountIds) {
 			throw new Error(
@@ -206,15 +217,23 @@ export class DriftClient {
 			: new Map<string, number[]>();
 
 		this.includeDelegates = config.includeDelegates ?? false;
-		this.userAccountSubscriptionConfig =
-			config.accountSubscription?.type === 'polling'
-				? {
-						type: 'polling',
-						accountLoader: config.accountSubscription.accountLoader,
-				  }
-				: {
-						type: 'websocket',
-				  };
+		if (config.accountSubscription?.type === 'polling') {
+			this.userAccountSubscriptionConfig = {
+				type: 'polling',
+				accountLoader: config.accountSubscription.accountLoader,
+			};
+			this.userStatsAccountSubscriptionConfig = {
+				type: 'polling',
+				accountLoader: config.accountSubscription.accountLoader,
+			};
+		} else {
+			this.userAccountSubscriptionConfig = {
+				type: 'websocket',
+			};
+			this.userStatsAccountSubscriptionConfig = {
+				type: 'websocket',
+			};
+		}
 
 		if (config.userStats) {
 			this.userStats = new UserStats({
@@ -257,7 +276,13 @@ export class DriftClient {
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
-		this.txSender = config.txSender ?? new RetryTxSender(this.provider);
+		this.txSender =
+			config.txSender ??
+			new RetryTxSender({
+				connection: this.connection,
+				wallet: this.wallet,
+				opts: this.opts,
+			});
 	}
 
 	public getUserMapKey(subAccountId: number, authority: PublicKey): string {
@@ -498,7 +523,7 @@ export class DriftClient {
 
 		this.skipLoadUsers = false;
 		// Update provider for txSender with new wallet details
-		this.txSender.provider = newProvider;
+		this.txSender.wallet = newWallet;
 		this.wallet = newWallet;
 		this.provider = newProvider;
 		this.program = newProgram;
@@ -542,7 +567,7 @@ export class DriftClient {
 				this.userStats = new UserStats({
 					driftClient: this,
 					userStatsAccountPublicKey: this.getUserStatsAccountPublicKey(),
-					accountSubscription: this.userAccountSubscriptionConfig,
+					accountSubscription: this.userStatsAccountSubscriptionConfig,
 				});
 
 				await this.userStats.subscribe();
@@ -838,6 +863,43 @@ export class DriftClient {
 		return txSig;
 	}
 
+	public async getUpdateUserMarginTradingEnabledIx(
+		marginTradingEnabled: boolean,
+		subAccountId = 0,
+		userAccountPublicKey?: PublicKey
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKeyToUse =
+			userAccountPublicKey ||
+			getUserAccountPublicKeySync(
+				this.program.programId,
+				this.wallet.publicKey,
+				subAccountId
+			);
+
+		await this.addUser(subAccountId, this.wallet.publicKey);
+
+		let remainingAccounts;
+		try {
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [this.getUserAccount(subAccountId)],
+			});
+		} catch (err) {
+			remainingAccounts = [];
+		}
+
+		return await this.program.instruction.updateUserMarginTradingEnabled(
+			subAccountId,
+			marginTradingEnabled,
+			{
+				accounts: {
+					user: userAccountPublicKeyToUse,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async updateUserMarginTradingEnabled(
 		marginTradingEnabled: boolean,
 		subAccountId = 0
@@ -1028,11 +1090,19 @@ export class DriftClient {
 		const userMapKey = this.getUserMapKey(subAccountId, authority);
 
 		if (!this.users.has(userMapKey)) {
-			throw new Error(`Clearing House has no user for user id ${userMapKey}`);
+			throw new Error(`DriftClient has no user for user id ${userMapKey}`);
 		}
 		return this.users.get(userMapKey);
 	}
 
+	public hasUser(subAccountId?: number, authority?: PublicKey): boolean {
+		subAccountId = subAccountId ?? this.activeSubAccountId;
+		authority = authority ?? this.authority;
+		const userMapKey = this.getUserMapKey(subAccountId, authority);
+
+		return this.users.has(userMapKey);
+	}
+
 	public getUsers(): User[] {
 		// delegate users get added to the end
 		return [...this.users.values()]
@@ -1167,6 +1237,29 @@ export class DriftClient {
 		return amount.mul(PRICE_PRECISION);
 	}
 
+	/**
+	 * Each drift instruction must include perp and sport market accounts in the ix remaining accounts.
+	 * Use this function to force a subset of markets to be included in the remaining accounts for every ix
+	 *
+	 * @param perpMarketIndexes
+	 * @param spotMarketIndexes
+	 */
+	public mustIncludeMarketsInIx({
+		perpMarketIndexes,
+		spotMarketIndexes,
+	}: {
+		perpMarketIndexes: number[];
+		spotMarketIndexes: number[];
+	}): void {
+		perpMarketIndexes.forEach((perpMarketIndex) => {
+			this.mustIncludePerpMarketIndexes.add(perpMarketIndex);
+		});
+
+		spotMarketIndexes.forEach((spotMarketIndex) => {
+			this.mustIncludeSpotMarketIndexes.add(spotMarketIndex);
+		});
+	}
+
 	getRemainingAccounts(params: RemainingAccountParams): AccountMeta[] {
 		const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } =
 			this.getRemainingAccountMapsForUsers(params.userAccounts);
@@ -1180,32 +1273,13 @@ export class DriftClient {
 				// if cache has more recent slot than user positions account slot, add market to remaining accounts
 				// otherwise remove from slot
 				if (slot > lastUserSlot) {
-					const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
-					perpMarketAccountMap.set(marketIndex, {
-						pubkey: perpMarketAccount.pubkey,
-						isSigner: false,
-						isWritable: false,
-					});
-					oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-						pubkey: perpMarketAccount.amm.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-					const spotMarketAccount = this.getSpotMarketAccount(
-						perpMarketAccount.quoteSpotMarketIndex
+					this.addPerpMarketToRemainingAccountMaps(
+						marketIndex,
+						false,
+						oracleAccountMap,
+						spotMarketAccountMap,
+						perpMarketAccountMap
 					);
-					spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-						pubkey: spotMarketAccount.pubkey,
-						isSigner: false,
-						isWritable: false,
-					});
-					if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-						oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-							pubkey: spotMarketAccount.oracle,
-							isSigner: false,
-							isWritable: false,
-						});
-					}
 				} else {
 					this.perpMarketLastSlotCache.delete(marketIndex);
 				}
@@ -1218,19 +1292,12 @@ export class DriftClient {
 				// if cache has more recent slot than user positions account slot, add market to remaining accounts
 				// otherwise remove from slot
 				if (slot > lastUserSlot) {
-					const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-					spotMarketAccountMap.set(marketIndex, {
-						pubkey: spotMarketAccount.pubkey,
-						isSigner: false,
-						isWritable: false,
-					});
-					if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-						oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-							pubkey: spotMarketAccount.oracle,
-							isSigner: false,
-							isWritable: false,
-						});
-					}
+					this.addSpotMarketToRemainingAccountMaps(
+						marketIndex,
+						false,
+						oracleAccountMap,
+						spotMarketAccountMap
+					);
 				} else {
 					this.spotMarketLastSlotCache.delete(marketIndex);
 				}
@@ -1238,106 +1305,72 @@ export class DriftClient {
 		}
 
 		if (params.readablePerpMarketIndex !== undefined) {
-			const perpMarketAccount = this.getPerpMarketAccount(
+			const readablePerpMarketIndexes = Array.isArray(
 				params.readablePerpMarketIndex
-			);
-			perpMarketAccountMap.set(params.readablePerpMarketIndex, {
-				pubkey: perpMarketAccount.pubkey,
-				isSigner: false,
-				isWritable: false,
-			});
-			oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-				pubkey: perpMarketAccount.amm.oracle,
-				isSigner: false,
-				isWritable: false,
-			});
-			const spotMarketAccount = this.getSpotMarketAccount(
-				perpMarketAccount.quoteSpotMarketIndex
-			);
-			spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-				pubkey: spotMarketAccount.pubkey,
-				isSigner: false,
-				isWritable: false,
-			});
-			if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-				oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-					pubkey: spotMarketAccount.oracle,
-					isSigner: false,
-					isWritable: false,
-				});
+			)
+				? params.readablePerpMarketIndex
+				: [params.readablePerpMarketIndex];
+			for (const marketIndex of readablePerpMarketIndexes) {
+				this.addPerpMarketToRemainingAccountMaps(
+					marketIndex,
+					false,
+					oracleAccountMap,
+					spotMarketAccountMap,
+					perpMarketAccountMap
+				);
 			}
 		}
 
+		for (const perpMarketIndex of this.mustIncludePerpMarketIndexes.values()) {
+			this.addPerpMarketToRemainingAccountMaps(
+				perpMarketIndex,
+				false,
+				oracleAccountMap,
+				spotMarketAccountMap,
+				perpMarketAccountMap
+			);
+		}
+
 		if (params.readableSpotMarketIndexes !== undefined) {
 			for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					readableSpotMarketIndex
+				this.addSpotMarketToRemainingAccountMaps(
+					readableSpotMarketIndex,
+					false,
+					oracleAccountMap,
+					spotMarketAccountMap
 				);
-				spotMarketAccountMap.set(readableSpotMarketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
 			}
 		}
 
+		for (const spotMarketIndex of this.mustIncludeSpotMarketIndexes.values()) {
+			this.addSpotMarketToRemainingAccountMaps(
+				spotMarketIndex,
+				false,
+				oracleAccountMap,
+				spotMarketAccountMap
+			);
+		}
+
 		if (params.writablePerpMarketIndexes !== undefined) {
 			for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
-				const perpMarketAccount = this.getPerpMarketAccount(
-					writablePerpMarketIndex
+				this.addPerpMarketToRemainingAccountMaps(
+					writablePerpMarketIndex,
+					true,
+					oracleAccountMap,
+					spotMarketAccountMap,
+					perpMarketAccountMap
 				);
-				perpMarketAccountMap.set(writablePerpMarketIndex, {
-					pubkey: perpMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: true,
-				});
-				oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-					pubkey: perpMarketAccount.amm.oracle,
-					isSigner: false,
-					isWritable: false,
-				});
-				const spotMarketAccount = this.getSpotMarketAccount(
-					perpMarketAccount.quoteSpotMarketIndex
-				);
-				spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
 			}
 		}
 
 		if (params.writableSpotMarketIndexes !== undefined) {
 			for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					writableSpotMarketIndex
+				this.addSpotMarketToRemainingAccountMaps(
+					writableSpotMarketIndex,
+					true,
+					oracleAccountMap,
+					spotMarketAccountMap
 				);
-				spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: true,
-				});
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
 			}
 		}
 
@@ -1348,6 +1381,53 @@ export class DriftClient {
 		];
 	}
 
+	addPerpMarketToRemainingAccountMaps(
+		marketIndex: number,
+		writable: boolean,
+		oracleAccountMap: Map<string, AccountMeta>,
+		spotMarketAccountMap: Map<number, AccountMeta>,
+		perpMarketAccountMap: Map<number, AccountMeta>
+	): void {
+		const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
+		perpMarketAccountMap.set(marketIndex, {
+			pubkey: perpMarketAccount.pubkey,
+			isSigner: false,
+			isWritable: writable,
+		});
+		oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
+			pubkey: perpMarketAccount.amm.oracle,
+			isSigner: false,
+			isWritable: false,
+		});
+		this.addSpotMarketToRemainingAccountMaps(
+			perpMarketAccount.quoteSpotMarketIndex,
+			false,
+			oracleAccountMap,
+			spotMarketAccountMap
+		);
+	}
+
+	addSpotMarketToRemainingAccountMaps(
+		marketIndex: number,
+		writable: boolean,
+		oracleAccountMap: Map<string, AccountMeta>,
+		spotMarketAccountMap: Map<number, AccountMeta>
+	): void {
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
+			pubkey: spotMarketAccount.pubkey,
+			isSigner: false,
+			isWritable: writable,
+		});
+		if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
+			oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+				pubkey: spotMarketAccount.oracle,
+				isSigner: false,
+				isWritable: false,
+			});
+		}
+	}
+
 	getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
 		oracleAccountMap: Map<string, AccountMeta>;
 		spotMarketAccountMap: Map<number, AccountMeta>;
@@ -1360,73 +1440,35 @@ export class DriftClient {
 		for (const userAccount of userAccounts) {
 			for (const spotPosition of userAccount.spotPositions) {
 				if (!isSpotPositionAvailable(spotPosition)) {
-					const spotMarket = this.getSpotMarketAccount(
-						spotPosition.marketIndex
+					this.addSpotMarketToRemainingAccountMaps(
+						spotPosition.marketIndex,
+						false,
+						oracleAccountMap,
+						spotMarketAccountMap
 					);
-					spotMarketAccountMap.set(spotPosition.marketIndex, {
-						pubkey: spotMarket.pubkey,
-						isSigner: false,
-						isWritable: false,
-					});
-
-					if (!spotMarket.oracle.equals(PublicKey.default)) {
-						oracleAccountMap.set(spotMarket.oracle.toString(), {
-							pubkey: spotMarket.oracle,
-							isSigner: false,
-							isWritable: false,
-						});
-					}
 
 					if (
 						!spotPosition.openAsks.eq(ZERO) ||
 						!spotPosition.openBids.eq(ZERO)
 					) {
-						const quoteSpotMarket = this.getQuoteSpotMarketAccount();
-						spotMarketAccountMap.set(QUOTE_SPOT_MARKET_INDEX, {
-							pubkey: quoteSpotMarket.pubkey,
-							isSigner: false,
-							isWritable: false,
-						});
-						if (!quoteSpotMarket.oracle.equals(PublicKey.default)) {
-							oracleAccountMap.set(quoteSpotMarket.oracle.toString(), {
-								pubkey: quoteSpotMarket.oracle,
-								isSigner: false,
-								isWritable: false,
-							});
-						}
+						this.addSpotMarketToRemainingAccountMaps(
+							QUOTE_SPOT_MARKET_INDEX,
+							false,
+							oracleAccountMap,
+							spotMarketAccountMap
+						);
 					}
 				}
 			}
 			for (const position of userAccount.perpPositions) {
 				if (!positionIsAvailable(position)) {
-					const perpMarketAccount = this.getPerpMarketAccount(
-						position.marketIndex
-					);
-					perpMarketAccountMap.set(position.marketIndex, {
-						pubkey: perpMarketAccount.pubkey,
-						isWritable: false,
-						isSigner: false,
-					});
-					oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-						pubkey: perpMarketAccount.amm.oracle,
-						isWritable: false,
-						isSigner: false,
-					});
-					const spotMarketAccount = this.getSpotMarketAccount(
-						perpMarketAccount.quoteSpotMarketIndex
+					this.addPerpMarketToRemainingAccountMaps(
+						position.marketIndex,
+						false,
+						oracleAccountMap,
+						spotMarketAccountMap,
+						perpMarketAccountMap
 					);
-					spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-						pubkey: spotMarketAccount.pubkey,
-						isSigner: false,
-						isWritable: false,
-					});
-					if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-						oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-							pubkey: spotMarketAccount.oracle,
-							isSigner: false,
-							isWritable: false,
-						});
-					}
 				}
 			}
 		}
@@ -1630,7 +1672,7 @@ export class DriftClient {
 		}
 	}
 
-	private async getWrappedSolAccountCreationIxs(
+	public async getWrappedSolAccountCreationIxs(
 		amount: BN,
 		includeRent?: boolean
 	): Promise<{
@@ -1690,7 +1732,7 @@ export class DriftClient {
 	}
 
 	/**
-	 * Creates the Clearing House User account for a user, and deposits some initial collateral
+	 * Creates the User account for a user, and deposits some initial collateral
 	 * @param amount
 	 * @param userTokenAccount
 	 * @param marketIndex
@@ -2291,6 +2333,35 @@ export class DriftClient {
 		});
 	}
 
+	public getQuoteValuePerLpShare(marketIndex: number): BN {
+		const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
+
+		const openBids = BN.max(
+			perpMarketAccount.amm.baseAssetReserve.sub(
+				perpMarketAccount.amm.minBaseAssetReserve
+			),
+			ZERO
+		);
+
+		const openAsks = BN.max(
+			perpMarketAccount.amm.maxBaseAssetReserve.sub(
+				perpMarketAccount.amm.baseAssetReserve
+			),
+			ZERO
+		);
+
+		const oraclePriceData = this.getOracleDataForPerpMarket(marketIndex);
+
+		const maxOpenBidsAsks = BN.max(openBids, openAsks);
+		const quoteValuePerLpShare = maxOpenBidsAsks
+			.mul(oraclePriceData.price)
+			.mul(QUOTE_PRECISION)
+			.div(PRICE_PRECISION)
+			.div(perpMarketAccount.amm.sqrtK);
+
+		return quoteValuePerLpShare;
+	}
+
 	/**
 	 * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
 	 */
@@ -2756,32 +2827,65 @@ export class DriftClient {
 		placeOrderParams: OrderParams[],
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const tx = wrapInTx(
+		const ixs = [
 			await this.getCancelOrdersIx(
 				cancelOrderParams.marketType,
 				cancelOrderParams.marketIndex,
 				cancelOrderParams.direction
 			),
-			txParams?.computeUnits,
-			txParams?.computeUnitsPrice
+			await this.getPlaceOrdersIx(placeOrderParams),
+		];
+		const tx = await this.buildTransaction(ixs, txParams);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
+
+	public async placeOrders(
+		params: OrderParams[],
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getPlaceOrdersIx(params),
+				txParams
+			),
+			[],
+			this.opts
 		);
+		return txSig;
+	}
 
-		for (const placeOrderParam of placeOrderParams) {
-			const marketType = placeOrderParam.marketType;
-			if (!marketType) {
-				throw new Error('marketType must be set on placeOrderParams');
-			}
-			let ix;
-			if (isVariant(marketType, 'perp')) {
-				ix = this.getPlacePerpOrderIx(placeOrderParam);
+	public async getPlaceOrdersIx(
+		params: OrderParams[]
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const readablePerpMarketIndex: number[] = [];
+		const readableSpotMarketIndexes: number[] = [];
+		for (const param of params) {
+			if (isVariant(param.marketType, 'perp')) {
+				readablePerpMarketIndex.push(param.marketIndex);
 			} else {
-				ix = this.getPlaceSpotOrderIx(placeOrderParam);
+				readableSpotMarketIndexes.push(param.marketIndex);
 			}
-			tx.add(ix);
 		}
 
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
-		return txSig;
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			readablePerpMarketIndex,
+			readableSpotMarketIndexes,
+			useMarketLastSlotCache: true,
+		});
+
+		return await this.program.instruction.placeOrders(params, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts,
+		});
 	}
 
 	public async fillPerpOrder(
@@ -3284,6 +3388,61 @@ export class DriftClient {
 		reduceOnly?: SwapReduceOnly;
 		txParams?: TxParams;
 	}): Promise<TransactionSignature> {
+		const { ixs, lookupTables } = await this.getJupiterSwapIx({
+			jupiterClient,
+			outMarketIndex,
+			inMarketIndex,
+			outAssociatedTokenAccount,
+			inAssociatedTokenAccount,
+			amount,
+			slippageBps,
+			swapMode,
+			route,
+			reduceOnly,
+		});
+
+		const tx = (await this.buildTransaction(
+			ixs,
+			txParams,
+			0,
+			lookupTables
+		)) as VersionedTransaction;
+
+		const { txSig, slot } = await this.sendTransaction(tx);
+		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
+		this.spotMarketLastSlotCache.set(inMarketIndex, slot);
+
+		return txSig;
+	}
+
+	public async getJupiterSwapIx({
+		jupiterClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		swapMode,
+		route,
+		reduceOnly,
+		userAccountPublicKey,
+	}: {
+		jupiterClient: JupiterClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount?: PublicKey;
+		inAssociatedTokenAccount?: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		route?: Route;
+		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
+	}): Promise<{
+		ixs: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
 		const outMarket = this.getSpotMarketAccount(outMarketIndex);
 		const inMarket = this.getSpotMarketAccount(inMarketIndex);
 
@@ -3370,27 +3529,17 @@ export class DriftClient {
 			inTokenAccount: inAssociatedTokenAccount,
 			outTokenAccount: outAssociatedTokenAccount,
 			reduceOnly,
+			userAccountPublicKey,
 		});
 
-		const instructions = [
+		const ixs = [
 			...preInstructions,
 			beginSwapIx,
 			...jupiterInstructions,
 			endSwapIx,
 		];
 
-		const tx = (await this.buildTransaction(
-			instructions,
-			txParams,
-			0,
-			lookupTables
-		)) as VersionedTransaction;
-
-		const { txSig, slot } = await this.sendTransaction(tx);
-		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
-		this.spotMarketLastSlotCache.set(inMarketIndex, slot);
-
-		return txSig;
+		return { ixs, lookupTables };
 	}
 
 	/**
@@ -3402,6 +3551,8 @@ export class DriftClient {
 	 * @param inTokenAccount the token account to move the tokens being sold
 	 * @param outTokenAccount the token account to receive the tokens being bought
 	 * @param limitPrice the limit price of the swap
+	 * @param reduceOnly
+	 * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
 	 */
 	public async getSwapIx({
 		outMarketIndex,
@@ -3411,6 +3562,7 @@ export class DriftClient {
 		outTokenAccount,
 		limitPrice,
 		reduceOnly,
+		userAccountPublicKey,
 	}: {
 		outMarketIndex: number;
 		inMarketIndex: number;
@@ -3419,14 +3571,17 @@ export class DriftClient {
 		outTokenAccount: PublicKey;
 		limitPrice?: BN;
 		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
 	}): Promise<{
 		beginSwapIx: TransactionInstruction;
 		endSwapIx: TransactionInstruction;
 	}> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccountPublicKeyToUse =
+			userAccountPublicKey || (await this.getUserAccountPublicKey());
 
+		const userAccounts = this.hasUser() ? [this.getUserAccount()] : [];
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
+			userAccounts,
 			writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
 		});
 
@@ -3440,7 +3595,7 @@ export class DriftClient {
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
+					user: userAccountPublicKeyToUse,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.authority,
 					outSpotMarketVault: outSpotMarket.vault,
@@ -3463,7 +3618,7 @@ export class DriftClient {
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
+					user: userAccountPublicKeyToUse,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.authority,
 					outSpotMarketVault: outSpotMarket.vault,
@@ -3481,6 +3636,66 @@ export class DriftClient {
 		return { beginSwapIx, endSwapIx };
 	}
 
+	public async stakeForMSOL({ amount }: { amount: BN }): Promise<TxSigAndSlot> {
+		const ixs = await this.getStakeForMSOLIx({ amount });
+		const tx = await this.buildTransaction(ixs);
+		return this.sendTransaction(tx);
+	}
+
+	public async getStakeForMSOLIx({
+		amount,
+		userAccountPublicKey,
+	}: {
+		amount: BN;
+		userAccountPublicKey?: PublicKey;
+	}): Promise<TransactionInstruction[]> {
+		const wSOLMint = this.getSpotMarketAccount(1).mint;
+		const mSOLAccount = await this.getAssociatedTokenAccount(2);
+		const wSOLAccount = await this.getAssociatedTokenAccount(1, false);
+
+		const wSOLAccountExists = await this.checkIfAccountExists(wSOLAccount);
+
+		const closeWSOLIx = createCloseAccountInstruction(
+			wSOLAccount,
+			this.wallet.publicKey,
+			this.wallet.publicKey
+		);
+
+		const createWSOLIx =
+			await this.createAssociatedTokenAccountIdempotentInstruction(
+				wSOLAccount,
+				this.wallet.publicKey,
+				this.wallet.publicKey,
+				wSOLMint
+			);
+
+		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+			inMarketIndex: 1,
+			outMarketIndex: 2,
+			amountIn: amount,
+			inTokenAccount: wSOLAccount,
+			outTokenAccount: mSOLAccount,
+			userAccountPublicKey,
+		});
+
+		const program = getMarinadeFinanceProgram(this.provider);
+		const depositIx = await getMarinadeDepositIx({
+			program,
+			mSOLAccount: mSOLAccount,
+			transferFrom: this.wallet.publicKey,
+			amount,
+		});
+
+		const ixs = [];
+
+		if (!wSOLAccountExists) {
+			ixs.push(createWSOLIx);
+		}
+		ixs.push(beginSwapIx, closeWSOLIx, depositIx, createWSOLIx, endSwapIx);
+
+		return ixs;
+	}
+
 	public async triggerOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
@@ -5361,7 +5576,7 @@ export class DriftClient {
 		lookupTables?: AddressLookupTableAccount[]
 	): Promise<Transaction | VersionedTransaction> {
 		const allIx = [];
-		const computeUnits = txParams?.computeUnits ?? 600_000;
+		const computeUnits = txParams?.computeUnits ?? this.txParams.computeUnits;
 		if (computeUnits !== 200_000) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitLimit({
@@ -5369,7 +5584,8 @@ export class DriftClient {
 				})
 			);
 		}
-		const computeUnitsPrice = txParams?.computeUnitsPrice ?? 0;
+		const computeUnitsPrice =
+			txParams?.computeUnitsPrice ?? this.txParams.computeUnitsPrice;
 		if (computeUnitsPrice !== 0) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitPrice({