@drift-labs/sdk 2.31.1-beta.9 → 2.32.1-beta.0

package/lib/driftClient.js

@@ -52,6 +52,8 @@ const market_1 = require("./math/market");
 const fetch_1 = require("./accounts/fetch");
 const spotMarket_1 = require("./math/spotMarket");
 const memcmp_1 = require("./memcmp");
+const marinade_1 = require("./marinade");
+const orderParams_1 = require("./orderParams");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -69,6 +71,8 @@ class DriftClient {
         this._isSubscribed = false;
         this.perpMarketLastSlotCache = new Map();
         this.spotMarketLastSlotCache = new Map();
+        this.mustIncludePerpMarketIndexes = new Set();
+        this.mustIncludeSpotMarketIndexes = new Set();
         this.connection = config.connection;
         this.wallet = config.wallet;
         this.opts = config.opts || anchor_1.AnchorProvider.defaultOptions();
@@ -505,6 +509,27 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
+    async getUpdateUserMarginTradingEnabledIx(marginTradingEnabled, subAccountId = 0, userAccountPublicKey) {
+        const userAccountPublicKeyToUse = userAccountPublicKey ||
+            (0, pda_1.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,
+        });
+    }
     async updateUserMarginTradingEnabled(marginTradingEnabled, subAccountId = 0) {
         const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId);
         await this.addUser(subAccountId, this.wallet.publicKey);
@@ -716,6 +741,21 @@ class DriftClient {
         amount = typeof amount === 'number' ? new anchor_1.BN(amount) : amount;
         return amount.mul(numericConstants_1.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
+     */
+    mustIncludeMarketsInIx({ perpMarketIndexes, spotMarketIndexes, }) {
+        perpMarketIndexes.forEach((perpMarketIndex) => {
+            this.mustIncludePerpMarketIndexes.add(perpMarketIndex);
+        });
+        spotMarketIndexes.forEach((spotMarketIndex) => {
+            this.mustIncludeSpotMarketIndexes.add(spotMarketIndex);
+        });
+    }
     getRemainingAccounts(params) {
         var _a;
         const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } = this.getRemainingAccountMapsForUsers(params.userAccounts);
@@ -725,30 +765,7 @@ 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);
-                    spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-                        pubkey: spotMarketAccount.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                            pubkey: spotMarketAccount.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addPerpMarketToRemainingAccountMaps(marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
                 }
                 else {
                     this.perpMarketLastSlotCache.delete(marketIndex);
@@ -758,19 +775,7 @@ 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(web3_js_1.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);
@@ -778,91 +783,32 @@ class DriftClient {
             }
         }
         if (params.readablePerpMarketIndex !== undefined) {
-            const perpMarketAccount = this.getPerpMarketAccount(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(web3_js_1.PublicKey.default)) {
-                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                    pubkey: spotMarketAccount.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
+            const readablePerpMarketIndexes = Array.isArray(params.readablePerpMarketIndex)
+                ? 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);
-                spotMarketAccountMap.set(readableSpotMarketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
+                this.addSpotMarketToRemainingAccountMaps(readableSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
             }
         }
+        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);
-                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(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
+                this.addPerpMarketToRemainingAccountMaps(writablePerpMarketIndex, true, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
             }
         }
         if (params.writableSpotMarketIndexes !== undefined) {
             for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
-                const spotMarketAccount = this.getSpotMarketAccount(writableSpotMarketIndex);
-                spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                });
-                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
+                this.addSpotMarketToRemainingAccountMaps(writableSpotMarketIndex, true, oracleAccountMap, spotMarketAccountMap);
             }
         }
         return [
@@ -871,6 +817,35 @@ class DriftClient {
             ...perpMarketAccountMap.values(),
         ];
     }
+    addPerpMarketToRemainingAccountMaps(marketIndex, writable, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap) {
+        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, writable, oracleAccountMap, spotMarketAccountMap) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
+            pubkey: spotMarketAccount.pubkey,
+            isSigner: false,
+            isWritable: writable,
+        });
+        if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+            oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                pubkey: spotMarketAccount.oracle,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
+    }
     getRemainingAccountMapsForUsers(userAccounts) {
         const oracleAccountMap = new Map();
         const spotMarketAccountMap = new Map();
@@ -878,63 +853,16 @@ class DriftClient {
         for (const userAccount of userAccounts) {
             for (const spotPosition of userAccount.spotPositions) {
                 if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                    const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
-                    spotMarketAccountMap.set(spotPosition.marketIndex, {
-                        pubkey: spotMarket.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarket.oracle.toString(), {
-                            pubkey: spotMarket.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addSpotMarketToRemainingAccountMaps(spotPosition.marketIndex, false, oracleAccountMap, spotMarketAccountMap);
                     if (!spotPosition.openAsks.eq(numericConstants_1.ZERO) ||
                         !spotPosition.openBids.eq(numericConstants_1.ZERO)) {
-                        const quoteSpotMarket = this.getQuoteSpotMarketAccount();
-                        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, {
-                            pubkey: quoteSpotMarket.pubkey,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                        if (!quoteSpotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
-                            oracleAccountMap.set(quoteSpotMarket.oracle.toString(), {
-                                pubkey: quoteSpotMarket.oracle,
-                                isSigner: false,
-                                isWritable: false,
-                            });
-                        }
+                        this.addSpotMarketToRemainingAccountMaps(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, false, oracleAccountMap, spotMarketAccountMap);
                     }
                 }
             }
             for (const position of userAccount.perpPositions) {
                 if (!(0, position_1.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);
-                    spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-                        pubkey: spotMarketAccount.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                            pubkey: spotMarketAccount.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addPerpMarketToRemainingAccountMaps(position.marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
                 }
             }
         }
@@ -1466,13 +1394,8 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    getOrderParams(optionalOrderParams, marketType) {
-        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams, {
-            marketType,
-        });
-    }
     async getPlacePerpOrderIx(orderParams) {
-        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [this.getUserAccount()],
@@ -1645,23 +1568,48 @@ class DriftClient {
         });
     }
     async cancelAndPlaceOrders(cancelOrderParams, placeOrderParams, txParams) {
-        const tx = (0, utils_1.wrapInTx)(await this.getCancelOrdersIx(cancelOrderParams.marketType, cancelOrderParams.marketIndex, cancelOrderParams.direction), txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice);
-        for (const placeOrderParam of placeOrderParams) {
-            const marketType = placeOrderParam.marketType;
-            if (!marketType) {
-                throw new Error('marketType must be set on placeOrderParams');
+        const ixs = [
+            await this.getCancelOrdersIx(cancelOrderParams.marketType, cancelOrderParams.marketIndex, cancelOrderParams.direction),
+            await this.getPlaceOrdersIx(placeOrderParams),
+        ];
+        const tx = await this.buildTransaction(ixs, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async placeOrders(params, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceOrdersIx(params), txParams), [], this.opts);
+        return txSig;
+    }
+    async getPlaceOrdersIx(params) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const readablePerpMarketIndex = [];
+        const readableSpotMarketIndexes = [];
+        for (const param of params) {
+            if (!param.marketType) {
+                throw new Error('must set param.marketType');
             }
-            let ix;
-            if ((0, types_1.isVariant)(marketType, 'perp')) {
-                ix = this.getPlacePerpOrderIx(placeOrderParam);
+            if ((0, types_1.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,
+        });
     }
     async fillPerpOrder(userAccountPublicKey, user, order, makerInfo, referrerInfo, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getFillPerpOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo), txParams), [], this.opts);
@@ -1747,7 +1695,7 @@ class DriftClient {
         return txSig;
     }
     async getPlaceSpotOrderIx(orderParams) {
-        orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.SPOT });
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [this.getUserAccount()],
@@ -1997,6 +1945,25 @@ class DriftClient {
      * @param txParams
      */
     async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }) {
+        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));
+        const { txSig, slot } = await this.sendTransaction(tx);
+        this.spotMarketLastSlotCache.set(outMarketIndex, slot);
+        this.spotMarketLastSlotCache.set(inMarketIndex, slot);
+        return txSig;
+    }
+    async getJupiterSwapIx({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, userAccountPublicKey, }) {
         const outMarket = this.getSpotMarketAccount(outMarketIndex);
         const inMarket = this.getSpotMarketAccount(inMarketIndex);
         if (!route) {
@@ -2047,18 +2014,15 @@ 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));
-        const { txSig, slot } = await this.sendTransaction(tx);
-        this.spotMarketLastSlotCache.set(outMarketIndex, slot);
-        this.spotMarketLastSlotCache.set(inMarketIndex, slot);
-        return txSig;
+        return { ixs, lookupTables };
     }
     /**
      * Get the drift begin_swap and end_swap instructions
@@ -2069,11 +2033,14 @@ 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
      */
-    async getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, }) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }) {
+        const userAccountPublicKeyToUse = userAccountPublicKey || (await this.getUserAccountPublicKey());
+        const userAccounts = this.hasUser() ? [this.getUserAccount()] : [];
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts,
             writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
         });
         const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
@@ -2081,7 +2048,7 @@ class DriftClient {
         const beginSwapIx = await this.program.instruction.beginSwap(inMarketIndex, outMarketIndex, amountIn, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user: userAccountPublicKeyToUse,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.authority,
                 outSpotMarketVault: outSpotMarket.vault,
@@ -2097,7 +2064,7 @@ class DriftClient {
         const endSwapIx = await this.program.instruction.endSwap(inMarketIndex, outMarketIndex, limitPrice !== null && limitPrice !== void 0 ? limitPrice : null, reduceOnly !== null && reduceOnly !== void 0 ? reduceOnly : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user: userAccountPublicKeyToUse,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.authority,
                 outSpotMarketVault: outSpotMarket.vault,
@@ -2112,6 +2079,40 @@ class DriftClient {
         });
         return { beginSwapIx, endSwapIx };
     }
+    async stakeForMSOL({ amount }) {
+        const ixs = await this.getStakeForMSOLIx({ amount });
+        const tx = await this.buildTransaction(ixs);
+        return this.sendTransaction(tx);
+    }
+    async getStakeForMSOLIx({ amount, userAccountPublicKey, }) {
+        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 = (0, spl_token_1.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 = (0, marinade_1.getMarinadeFinanceProgram)(this.provider);
+        const depositIx = await (0, marinade_1.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;
+    }
     async triggerOrder(userAccountPublicKey, user, order, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getTriggerOrderIx(userAccountPublicKey, user, order), txParams), [], this.opts);
         return txSig;
@@ -2207,7 +2208,7 @@ class DriftClient {
         return txSig;
     }
     async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo) {
-        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         makerInfo = Array.isArray(makerInfo)
@@ -2268,7 +2269,7 @@ class DriftClient {
         return txSig;
     }
     async getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo) {
-        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
@@ -2308,7 +2309,7 @@ class DriftClient {
         return txSig;
     }
     async getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo) {
-        orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.SPOT });
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const userAccounts = [this.getUserAccount()];
@@ -2367,7 +2368,7 @@ class DriftClient {
         return txSig;
     }
     async getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo) {
-        orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.SPOT });
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.31.1-beta.8",
+    "version": "2.32.0",
     "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/lib/index.d.ts

@@ -16,6 +16,7 @@ export * from './accounts/pollingOracleAccountSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/pollingUserAccountSubscriber';
 export * from './accounts/pollingUserStatsAccountSubscriber';
+export * from './accounts/mockUserAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './adminClient';
@@ -45,6 +46,8 @@ export * from './math/orders';
 export * from './math/repeg';
 export * from './math/margin';
 export * from './math/insurance';
+export * from './math/superStake';
+export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';

package/lib/index.js

@@ -39,6 +39,7 @@ __exportStar(require("./accounts/pollingOracleAccountSubscriber"), exports);
 __exportStar(require("./accounts/pollingTokenAccountSubscriber"), exports);
 __exportStar(require("./accounts/pollingUserAccountSubscriber"), exports);
 __exportStar(require("./accounts/pollingUserStatsAccountSubscriber"), exports);
+__exportStar(require("./accounts/mockUserAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
 __exportStar(require("./addresses/pda"), exports);
 __exportStar(require("./adminClient"), exports);
@@ -68,6 +69,8 @@ __exportStar(require("./math/orders"), exports);
 __exportStar(require("./math/repeg"), exports);
 __exportStar(require("./math/margin"), exports);
 __exportStar(require("./math/insurance"), exports);
+__exportStar(require("./math/superStake"), exports);
+__exportStar(require("./marinade"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);
 __exportStar(require("./wallet"), exports);

package/lib/marinade/index.d.ts

@@ -0,0 +1,11 @@
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { MarinadeFinance } from './types';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare function getMarinadeFinanceProgram(provider: AnchorProvider): Program<MarinadeFinance>;
+export declare function getMarinadeDepositIx({ program, amount, mSOLAccount, transferFrom, }: {
+    amount: BN;
+    mSOLAccount: PublicKey;
+    transferFrom: PublicKey;
+    program: Program<MarinadeFinance>;
+}): Promise<TransactionInstruction>;
+export declare function getMarinadeMSolPrice(program: Program<MarinadeFinance>): Promise<number>;