@drift-labs/sdk 2.31.1-beta.10 → 2.31.1-beta.12

package/package.json

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

package/src/driftClient.ts

@@ -117,12 +117,13 @@ 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;
 };
@@ -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;
@@ -1197,6 +1200,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 +1236,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 +1255,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 +1268,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 +1344,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 +1403,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,
-						});
-					}
 				}
 			}
 		}
@@ -2815,32 +2790,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(
@@ -3540,6 +3548,63 @@ 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,
+	}: {
+		amount: BN;
+	}): 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,
+		});
+
+		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,

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.31.1-beta.10",
+  "version": "2.31.1-beta.12",
   "name": "drift",
   "instructions": [
     {
@@ -710,6 +710,36 @@
         }
       ]
     },
+    {
+      "name": "placeOrders",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        }
+      ],
+      "args": [
+        {
+          "name": "params",
+          "type": {
+            "vec": {
+              "defined": "OrderParams"
+            }
+          }
+        }
+      ]
+    },
     {
       "name": "beginSwap",
       "accounts": [

package/src/index.ts

@@ -46,6 +46,7 @@ export * from './math/orders';
 export * from './math/repeg';
 export * from './math/margin';
 export * from './math/insurance';
+export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';