@drift-labs/sdk 2.31.1-beta.9 → 2.32.0

package/src/driftClient.ts

@@ -27,7 +27,6 @@ import {
 	MakerInfo,
 	TakerInfo,
 	OptionalOrderParams,
-	DefaultOrderParams,
 	OrderType,
 	ReferrerInfo,
 	MarketType,
@@ -117,12 +116,14 @@ 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';
+import { getOrderParams } from './orderParams';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
 	writablePerpMarketIndexes?: number[];
 	writableSpotMarketIndexes?: number[];
-	readablePerpMarketIndex?: number;
+	readablePerpMarketIndex?: number | number[];
 	readableSpotMarketIndexes?: number[];
 	useMarketLastSlotCache?: boolean;
 };
@@ -148,6 +149,8 @@ export class DriftClient {
 	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;
@@ -860,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
@@ -1197,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);
@@ -1210,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);
 				}
@@ -1248,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);
 				}
@@ -1268,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,
-					});
-				}
 			}
 		}
 
@@ -1378,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>;
@@ -1390,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,
-						});
-					}
 				}
 			}
 		}
@@ -1660,7 +1672,7 @@ export class DriftClient {
 		}
 	}
 
-	private async getWrappedSolAccountCreationIxs(
+	public async getWrappedSolAccountCreationIxs(
 		amount: BN,
 		includeRent?: boolean
 	): Promise<{
@@ -2510,19 +2522,10 @@ export class DriftClient {
 		return txSig;
 	}
 
-	getOrderParams(
-		optionalOrderParams: OptionalOrderParams,
-		marketType: MarketType
-	): OrderParams {
-		return Object.assign({}, DefaultOrderParams, optionalOrderParams, {
-			marketType,
-		});
-	}
-
 	public async getPlacePerpOrderIx(
 		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
-		orderParams = this.getOrderParams(orderParams, MarketType.PERP);
+		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
@@ -2815,32 +2818,68 @@ 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;
+	}
+
+	public async getPlaceOrdersIx(
+		params: OrderParams[]
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		for (const placeOrderParam of placeOrderParams) {
-			const marketType = placeOrderParam.marketType;
-			if (!marketType) {
-				throw new Error('marketType must be set on placeOrderParams');
+		const readablePerpMarketIndex: number[] = [];
+		const readableSpotMarketIndexes: number[] = [];
+		for (const param of params) {
+			if (!param.marketType) {
+				throw new Error('must set param.marketType');
 			}
-			let ix;
-			if (isVariant(marketType, 'perp')) {
-				ix = this.getPlacePerpOrderIx(placeOrderParam);
+			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(
@@ -2983,7 +3022,7 @@ export class DriftClient {
 	public async getPlaceSpotOrderIx(
 		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
-		orderParams = this.getOrderParams(orderParams, MarketType.SPOT);
+		orderParams = getOrderParams(orderParams, { marketType: MarketType.SPOT });
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
@@ -3343,6 +3382,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);
 
@@ -3429,27 +3523,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 };
 	}
 
 	/**
@@ -3461,6 +3545,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,
@@ -3470,6 +3556,7 @@ export class DriftClient {
 		outTokenAccount,
 		limitPrice,
 		reduceOnly,
+		userAccountPublicKey,
 	}: {
 		outMarketIndex: number;
 		inMarketIndex: number;
@@ -3478,14 +3565,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],
 		});
 
@@ -3499,7 +3589,7 @@ export class DriftClient {
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
+					user: userAccountPublicKeyToUse,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.authority,
 					outSpotMarketVault: outSpotMarket.vault,
@@ -3522,7 +3612,7 @@ export class DriftClient {
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
+					user: userAccountPublicKeyToUse,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.authority,
 					outSpotMarketVault: outSpotMarket.vault,
@@ -3540,6 +3630,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,
@@ -3732,7 +3882,7 @@ export class DriftClient {
 		makerInfo?: MakerInfo | MakerInfo[],
 		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
-		orderParams = this.getOrderParams(orderParams, MarketType.PERP);
+		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
 		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
@@ -3828,7 +3978,7 @@ export class DriftClient {
 		takerInfo: TakerInfo,
 		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
-		orderParams = this.getOrderParams(orderParams, MarketType.PERP);
+		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
 		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
@@ -3900,7 +4050,7 @@ export class DriftClient {
 		makerInfo?: MakerInfo,
 		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
-		orderParams = this.getOrderParams(orderParams, MarketType.SPOT);
+		orderParams = getOrderParams(orderParams, { marketType: MarketType.SPOT });
 		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
@@ -3998,7 +4148,7 @@ export class DriftClient {
 		fulfillmentConfig?: SerumV3FulfillmentConfigAccount,
 		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
-		orderParams = this.getOrderParams(orderParams, MarketType.SPOT);
+		orderParams = getOrderParams(orderParams, { marketType: MarketType.SPOT });
 		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();