@drift-labs/sdk 2.49.0-beta.4 → 2.49.0-beta.5

package/lib/driftClient.js

@@ -727,8 +727,8 @@ class DriftClient {
     getUserAccountAndSlot(subAccountId) {
         return this.getUser(subAccountId).getUserAccountAndSlot();
     }
-    getSpotPosition(marketIndex) {
-        return this.getUserAccount().spotPositions.find((spotPosition) => spotPosition.marketIndex === marketIndex);
+    getSpotPosition(marketIndex, subAccountId) {
+        return this.getUserAccount(subAccountId).spotPositions.find((spotPosition) => spotPosition.marketIndex === marketIndex);
     }
     getQuoteAssetTokenAmount() {
         return this.getTokenAmount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
@@ -902,13 +902,13 @@ class DriftClient {
             perpMarketAccountMap,
         };
     }
-    getOrder(orderId) {
+    getOrder(orderId, subAccountId) {
         var _a;
-        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.orderId === orderId);
+        return (_a = this.getUserAccount(subAccountId)) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.orderId === orderId);
     }
-    getOrderByUserId(userOrderId) {
+    getOrderByUserId(userOrderId, subAccountId) {
         var _a;
-        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.userOrderId === userOrderId);
+        return (_a = this.getUserAccount(subAccountId)) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.userOrderId === userOrderId);
     }
     /**
      * Get the associated token address for the given spot market
@@ -944,11 +944,11 @@ class DriftClient {
     /**
      * Deposit funds into the given spot market
      *
-     * @param amount
-     * @param marketIndex
+     * @param amount to deposit
+     * @param marketIndex spot market index to deposit into
      * @param associatedTokenAccount can be the wallet public key if using native sol
-     * @param subAccountId
-     * @param reduceOnly
+     * @param subAccountId subaccountId to deposit
+     * @param reduceOnly if true, deposit must not increase account risk
      */
     async deposit(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false) {
         const additionalSigners = [];
@@ -975,7 +975,7 @@ class DriftClient {
         return txSig;
     }
     async getDepositInstruction(amount, marketIndex, userTokenAccount, subAccountId, reduceOnly = false, userInitialized = true) {
-        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId !== null && subAccountId !== void 0 ? subAccountId : this.activeSubAccountId);
+        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, subAccountId);
         let remainingAccounts = [];
         if (userInitialized) {
             remainingAccounts = this.getRemainingAccounts({
@@ -1124,7 +1124,7 @@ class DriftClient {
      * @param associatedTokenAddress - the token account to withdraw to. can be the wallet public key if using native sol
      * @param reduceOnly
      */
-    async withdraw(amount, marketIndex, associatedTokenAddress, reduceOnly = false) {
+    async withdraw(amount, marketIndex, associatedTokenAddress, reduceOnly = false, subAccountId) {
         const withdrawIxs = [];
         const additionalSigners = [];
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
@@ -1143,7 +1143,7 @@ class DriftClient {
                 withdrawIxs.push(createAssociatedTokenAccountIx);
             }
         }
-        const withdrawCollateralIx = await this.getWithdrawIx(amount, spotMarketAccount.marketIndex, associatedTokenAddress, reduceOnly);
+        const withdrawCollateralIx = await this.getWithdrawIx(amount, spotMarketAccount.marketIndex, associatedTokenAddress, reduceOnly, subAccountId);
         withdrawIxs.push(withdrawCollateralIx);
         // Close the wrapped sol account at the end of the transaction
         if (createWSOLTokenAccount) {
@@ -1156,10 +1156,10 @@ class DriftClient {
         this.spotMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
-    async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
             writableSpotMarketIndexes: [marketIndex],
             readableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
@@ -1171,7 +1171,7 @@ class DriftClient {
                 spotMarket: spotMarketAccount.pubkey,
                 spotMarketVault: spotMarketAccount.vault,
                 driftSigner: this.getSignerPublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: this.getUserStatsAccountPublicKey(),
                 userTokenAccount: userTokenAccount,
                 authority: this.wallet.publicKey,
@@ -1262,8 +1262,8 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
-    async removePerpLpShares(marketIndex, sharesToBurn, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getRemovePerpLpSharesIx(marketIndex, sharesToBurn), txParams), [], this.opts);
+    async removePerpLpShares(marketIndex, sharesToBurn, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getRemovePerpLpSharesIx(marketIndex, sharesToBurn, subAccountId), txParams), [], this.opts);
         return txSig;
     }
     async removePerpLpSharesInExpiringMarket(marketIndex, userAccountPublicKey, sharesToBurn, txParams) {
@@ -1290,15 +1290,15 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
-    async getRemovePerpLpSharesIx(marketIndex, sharesToBurn) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getRemovePerpLpSharesIx(marketIndex, sharesToBurn, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
             writablePerpMarketIndexes: [marketIndex],
         });
         if (sharesToBurn == undefined) {
-            const userAccount = this.getUserAccount();
+            const userAccount = this.getUserAccount(subAccountId);
             const perpPosition = userAccount.perpPositions.filter((position) => position.marketIndex === marketIndex)[0];
             sharesToBurn = perpPosition.lpShares;
             console.log('burning lp shares:', sharesToBurn.toString());
@@ -1306,28 +1306,28 @@ class DriftClient {
         return this.program.instruction.removePerpLpShares(sharesToBurn, marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async addPerpLpShares(amount, marketIndex, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getAddPerpLpSharesIx(amount, marketIndex), txParams), [], this.opts);
+    async addPerpLpShares(amount, marketIndex, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getAddPerpLpSharesIx(amount, marketIndex, subAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
-    async getAddPerpLpSharesIx(amount, marketIndex) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getAddPerpLpSharesIx(amount, marketIndex, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
             writablePerpMarketIndexes: [marketIndex],
         });
         return this.program.instruction.addPerpLpShares(amount, marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts: remainingAccounts,
@@ -1349,14 +1349,14 @@ class DriftClient {
     /**
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
-    async openPosition(direction, amount, marketIndex, limitPrice) {
+    async openPosition(direction, amount, marketIndex, limitPrice, subAccountId) {
         return await this.placeAndTakePerpOrder({
             orderType: types_1.OrderType.MARKET,
             marketIndex,
             direction,
             baseAssetAmount: amount,
             price: limitPrice,
-        });
+        }, undefined, undefined, undefined, subAccountId);
     }
     async sendSignedTx(tx) {
         const { txSig } = await this.sendTransaction(tx, undefined, this.opts, true);
@@ -1377,15 +1377,15 @@ class DriftClient {
         const marketIndex = orderParams.marketIndex;
         const orderId = userAccount.nextOrderId;
         const bracketOrderIxs = [];
-        const placePerpOrderIx = await this.getPlacePerpOrderIx(orderParams);
+        const placePerpOrderIx = await this.getPlacePerpOrderIx(orderParams, userAccount.subAccountId);
         for (const bracketOrderParams of bracketOrdersParams) {
-            const placeBracketOrderIx = await this.getPlacePerpOrderIx(bracketOrderParams);
+            const placeBracketOrderIx = await this.getPlacePerpOrderIx(bracketOrderParams, userAccount.subAccountId);
             bracketOrderIxs.push(placeBracketOrderIx);
         }
         let cancelOrdersIx;
         let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
-            cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null);
+            cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
             //@ts-ignore
             cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
         }
@@ -1395,7 +1395,7 @@ class DriftClient {
             const fillPerpOrderIx = await this.getFillPerpOrderIx(userAccountPublicKey, userAccount, {
                 orderId,
                 marketIndex,
-            }, makerInfo, referrerInfo);
+            }, makerInfo, referrerInfo, userAccount.subAccountId);
             const versionedFillTx = await this.buildTransaction([fillPerpOrderIx], txParams, 0);
             const [signedVersionedMarketOrderTx, signedVersionedFillTx, signedCancelExistingOrdersTx,] = await this.provider.wallet.signAllTransactions([
                 versionedMarketOrderTx,
@@ -1431,23 +1431,23 @@ class DriftClient {
             return { txSig, signedFillTx: undefined, signedCancelExistingOrdersTx };
         }
     }
-    async placePerpOrder(orderParams, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlacePerpOrderIx(orderParams), txParams), [], this.opts);
+    async placePerpOrder(orderParams, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlacePerpOrderIx(orderParams, subAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlacePerpOrderIx(orderParams) {
+    async getPlacePerpOrderIx(orderParams, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
             readablePerpMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placePerpOrder(orderParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
             },
@@ -1537,72 +1537,72 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(ix, txParams), [], this.opts);
         return txSig;
     }
-    async cancelOrder(orderId, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrderIx(orderId), txParams), [], this.opts);
+    async cancelOrder(orderId, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrderIx(orderId, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getCancelOrderIx(orderId) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getCancelOrderIx(orderId, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
         });
         return await this.program.instruction.cancelOrder(orderId !== null && orderId !== void 0 ? orderId : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async cancelOrderByUserId(userOrderId, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrderByUserIdIx(userOrderId), txParams), [], this.opts);
+    async cancelOrderByUserId(userOrderId, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrderByUserIdIx(userOrderId, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getCancelOrderByUserIdIx(userOrderId) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getCancelOrderByUserIdIx(userOrderId, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const order = this.getOrderByUserId(userOrderId);
         const oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
         });
         return await this.program.instruction.cancelOrderByUserId(userOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 authority: this.wallet.publicKey,
                 oracle,
             },
             remainingAccounts,
         });
     }
-    async cancelOrdersByIds(orderIds, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrdersByIdsIx(orderIds), txParams), [], this.opts);
+    async cancelOrdersByIds(orderIds, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrdersByIdsIx(orderIds, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getCancelOrdersByIdsIx(orderIds) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getCancelOrdersByIdsIx(orderIds, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
         });
         return await this.program.instruction.cancelOrdersByIds(orderIds, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async cancelOrders(marketType, marketIndex, direction, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrdersIx(marketType, marketIndex, direction), txParams), [], this.opts);
+    async cancelOrders(marketType, marketIndex, direction, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getCancelOrdersIx(marketType, marketIndex, direction, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getCancelOrdersIx(marketType, marketIndex, direction) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getCancelOrdersIx(marketType, marketIndex, direction, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         let readablePerpMarketIndex = undefined;
         let readableSpotMarketIndexes = undefined;
         if (typeof marketIndex === 'number') {
@@ -1614,7 +1614,7 @@ class DriftClient {
             }
         }
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             readablePerpMarketIndex,
             readableSpotMarketIndexes,
             useMarketLastSlotCache: true,
@@ -1622,27 +1622,27 @@ class DriftClient {
         return await this.program.instruction.cancelOrders(marketType !== null && marketType !== void 0 ? marketType : null, marketIndex !== null && marketIndex !== void 0 ? marketIndex : null, direction !== null && direction !== void 0 ? direction : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async cancelAndPlaceOrders(cancelOrderParams, placeOrderParams, txParams) {
+    async cancelAndPlaceOrders(cancelOrderParams, placeOrderParams, txParams, subAccountId) {
         const ixs = [
-            await this.getCancelOrdersIx(cancelOrderParams.marketType, cancelOrderParams.marketIndex, cancelOrderParams.direction),
-            await this.getPlaceOrdersIx(placeOrderParams),
+            await this.getCancelOrdersIx(cancelOrderParams.marketType, cancelOrderParams.marketIndex, cancelOrderParams.direction, subAccountId),
+            await this.getPlaceOrdersIx(placeOrderParams, subAccountId),
         ];
         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);
+    async placeOrders(params, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getPlaceOrdersIx(params) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getPlaceOrdersIx(params, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const readablePerpMarketIndex = [];
         const readableSpotMarketIndexes = [];
         for (const param of params) {
@@ -1657,7 +1657,7 @@ class DriftClient {
             }
         }
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             readablePerpMarketIndex,
             readableSpotMarketIndexes,
             useMarketLastSlotCache: true,
@@ -1665,20 +1665,20 @@ class DriftClient {
         return await this.program.instruction.placeOrders(params, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 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);
+    async fillPerpOrder(userAccountPublicKey, user, order, makerInfo, referrerInfo, txParams, fillerPublicKey) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getFillPerpOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo, fillerPublicKey), txParams), [], this.opts);
         return txSig;
     }
-    async getFillPerpOrderIx(userAccountPublicKey, userAccount, order, makerInfo, referrerInfo) {
+    async getFillPerpOrderIx(userAccountPublicKey, userAccount, order, makerInfo, referrerInfo, fillerSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const filler = await this.getUserAccountPublicKey(fillerSubAccountId);
         const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         const marketIndex = order
             ? order.marketIndex
@@ -1728,7 +1728,7 @@ class DriftClient {
         return await this.program.instruction.fillPerpOrder(orderId, null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 fillerStats: fillerStatsPublicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
@@ -1737,29 +1737,29 @@ class DriftClient {
             remainingAccounts,
         });
     }
-    async getRevertFillIx() {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+    async getRevertFillIx(fillerPublicKey) {
+        const filler = fillerPublicKey !== null && fillerPublicKey !== void 0 ? fillerPublicKey : (await this.getUserAccountPublicKey());
         const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         return this.program.instruction.revertFill({
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 fillerStats: fillerStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
         });
     }
-    async placeSpotOrder(orderParams, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceSpotOrderIx(orderParams), txParams), [], this.opts);
+    async placeSpotOrder(orderParams, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceSpotOrderIx(orderParams, subAccountId), txParams), [], this.opts);
         this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
         this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
-    async getPlaceSpotOrderIx(orderParams) {
+    async getPlaceSpotOrderIx(orderParams, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.SPOT });
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const userAccountPublicKey = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
             readableSpotMarketIndexes: [
                 orderParams.marketIndex,
@@ -1780,9 +1780,9 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getFillSpotOrderIx(userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo), txParams), [], this.opts);
         return txSig;
     }
-    async getFillSpotOrderIx(userAccountPublicKey, userAccount, order, fulfillmentConfig, makerInfo, referrerInfo) {
+    async getFillSpotOrderIx(userAccountPublicKey, userAccount, order, fulfillmentConfig, makerInfo, referrerInfo, fillerPublicKey) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const filler = fillerPublicKey !== null && fillerPublicKey !== void 0 ? fillerPublicKey : (await this.getUserAccountPublicKey());
         const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         const marketIndex = order
             ? order.marketIndex
@@ -1825,7 +1825,7 @@ class DriftClient {
         return await this.program.instruction.fillSpotOrder(orderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 fillerStats: fillerStatsPublicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
@@ -2266,12 +2266,12 @@ class DriftClient {
         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);
+    async triggerOrder(userAccountPublicKey, user, order, txParams, fillerPublicKey) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getTriggerOrderIx(userAccountPublicKey, user, order, fillerPublicKey), txParams), [], this.opts);
         return txSig;
     }
-    async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+    async getTriggerOrderIx(userAccountPublicKey, userAccount, order, fillerPublicKey) {
+        const filler = fillerPublicKey !== null && fillerPublicKey !== void 0 ? fillerPublicKey : (await this.getUserAccountPublicKey());
         let remainingAccountsParams;
         if ((0, types_1.isVariant)(order.marketType, 'perp')) {
             remainingAccountsParams = {
@@ -2290,19 +2290,19 @@ class DriftClient {
         return await this.program.instruction.triggerOrder(orderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async forceCancelOrders(userAccountPublicKey, user, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getForceCancelOrdersIx(userAccountPublicKey, user), txParams), [], this.opts);
+    async forceCancelOrders(userAccountPublicKey, user, txParams, fillerPublicKey) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getForceCancelOrdersIx(userAccountPublicKey, user, fillerPublicKey), txParams), [], this.opts);
         return txSig;
     }
-    async getForceCancelOrdersIx(userAccountPublicKey, userAccount) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+    async getForceCancelOrdersIx(userAccountPublicKey, userAccount, fillerPublicKey) {
+        const filler = fillerPublicKey !== null && fillerPublicKey !== void 0 ? fillerPublicKey : (await this.getUserAccountPublicKey());
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [userAccount],
             writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
@@ -2310,66 +2310,66 @@ class DriftClient {
         return await this.program.instruction.forceCancelOrders({
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async updateUserIdle(userAccountPublicKey, user, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserIdleIx(userAccountPublicKey, user), txParams), [], this.opts);
+    async updateUserIdle(userAccountPublicKey, user, txParams, fillerPublicKey) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserIdleIx(userAccountPublicKey, user, fillerPublicKey), txParams), [], this.opts);
         return txSig;
     }
-    async getUpdateUserIdleIx(userAccountPublicKey, userAccount) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+    async getUpdateUserIdleIx(userAccountPublicKey, userAccount, fillerPublicKey) {
+        const filler = fillerPublicKey !== null && fillerPublicKey !== void 0 ? fillerPublicKey : (await this.getUserAccountPublicKey());
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [userAccount],
         });
         return await this.program.instruction.updateUserIdle({
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async updateUserOpenOrdersCount(userAccountPublicKey, user, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserOpenOrdersCountIx(userAccountPublicKey, user), txParams), [], this.opts);
+    async updateUserOpenOrdersCount(userAccountPublicKey, user, txParams, fillerPublicKey) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserOpenOrdersCountIx(userAccountPublicKey, user, fillerPublicKey), txParams), [], this.opts);
         return txSig;
     }
-    async getUpdateUserOpenOrdersCountIx(userAccountPublicKey, userAccount) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
+    async getUpdateUserOpenOrdersCountIx(userAccountPublicKey, userAccount, fillerPublicKey) {
+        const filler = fillerPublicKey !== null && fillerPublicKey !== void 0 ? fillerPublicKey : (await this.getUserAccountPublicKey());
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts: [userAccount],
         });
         return await this.program.instruction.updateUserOpenOrdersCount({
             accounts: {
                 state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
+                filler,
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async placeAndTakePerpOrder(orderParams, makerInfo, referrerInfo, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo), txParams), [], this.opts);
+    async placeAndTakePerpOrder(orderParams, makerInfo, referrerInfo, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo) {
+    async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const user = await this.getUserAccountPublicKey(subAccountId);
         makerInfo = Array.isArray(makerInfo)
             ? makerInfo
             : makerInfo
                 ? [makerInfo]
                 : [];
-        const userAccounts = [this.getUserAccount()];
+        const userAccounts = [this.getUserAccount(subAccountId)];
         for (const maker of makerInfo) {
             userAccounts.push(maker.makerUserAccount);
         }
@@ -2409,24 +2409,27 @@ class DriftClient {
         return await this.program.instruction.placeAndTakePerpOrder(orderParams, null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async placeAndMakePerpOrder(orderParams, takerInfo, referrerInfo, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo), txParams), [], this.opts);
+    async placeAndMakePerpOrder(orderParams, takerInfo, referrerInfo, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo, subAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo) {
+    async getPlaceAndMakePerpOrderIx(orderParams, takerInfo, referrerInfo, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+            userAccounts: [
+                this.getUserAccount(subAccountId),
+                takerInfo.takerUserAccount,
+            ],
             useMarketLastSlotCache: true,
             writablePerpMarketIndexes: [orderParams.marketIndex],
         });
@@ -2446,7 +2449,7 @@ class DriftClient {
         return await this.program.instruction.placeAndMakePerpOrder(orderParams, takerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: userStatsPublicKey,
                 taker: takerInfo.taker,
                 takerStats: takerInfo.takerStats,
@@ -2455,17 +2458,17 @@ class DriftClient {
             remainingAccounts,
         });
     }
-    async placeAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo), txParams), [], this.opts);
+    async placeAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo, subAccountId), txParams), [], this.opts);
         this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
         this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
-    async getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo) {
+    async getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo, subAccountId) {
         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()];
+        const userStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const user = await this.getUserAccountPublicKey(subAccountId);
+        const userAccounts = [this.getUserAccount(subAccountId)];
         if (makerInfo !== undefined) {
             userAccounts.push(makerInfo.makerUserAccount);
         }
@@ -2507,25 +2510,28 @@ class DriftClient {
         return await this.program.instruction.placeAndTakeSpotOrder(orderParams, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async placeAndMakeSpotOrder(orderParams, takerInfo, fulfillmentConfig, referrerInfo, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo), txParams), [], this.opts);
+    async placeAndMakeSpotOrder(orderParams, takerInfo, fulfillmentConfig, referrerInfo, txParams, subAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo, subAccountId), txParams), [], this.opts);
         this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
         this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
-    async getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo) {
+    async getPlaceAndMakeSpotOrderIx(orderParams, takerInfo, fulfillmentConfig, referrerInfo, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.SPOT });
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+            userAccounts: [
+                this.getUserAccount(subAccountId),
+                takerInfo.takerUserAccount,
+            ],
             useMarketLastSlotCache: true,
             writableSpotMarketIndexes: [
                 orderParams.marketIndex,
@@ -2549,7 +2555,7 @@ class DriftClient {
         return await this.program.instruction.placeAndMakeSpotOrder(orderParams, takerOrderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: userStatsPublicKey,
                 taker: takerInfo.taker,
                 takerStats: takerInfo.takerStats,
@@ -2561,8 +2567,8 @@ class DriftClient {
     /**
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
-    async closePosition(marketIndex, limitPrice) {
-        const userPosition = this.getUser().getPerpPosition(marketIndex);
+    async closePosition(marketIndex, limitPrice, subAccountId) {
+        const userPosition = this.getUser(subAccountId).getPerpPosition(marketIndex);
         if (!userPosition) {
             throw Error(`No position in market ${marketIndex.toString()}`);
         }
@@ -2573,7 +2579,7 @@ class DriftClient {
             baseAssetAmount: userPosition.baseAssetAmount.abs(),
             reduceOnly: true,
             price: limitPrice,
-        });
+        }, undefined, undefined, undefined, subAccountId);
     }
     /**
      * Modifies an open order by closing it and replacing it with a new order.
@@ -2627,14 +2633,14 @@ class DriftClient {
      * @param orderParams.maxTs:
      * @returns
      */
-    async modifyOrder(orderParams, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getModifyOrderIx(orderParams), txParams), [], this.opts);
+    async modifyOrder(orderParams, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getModifyOrderIx(orderParams, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getModifyOrderIx({ orderId, newDirection, newBaseAmount, newLimitPrice, newOraclePriceOffset, newTriggerPrice, newTriggerCondition, auctionDuration, auctionStartPrice, auctionEndPrice, reduceOnly, postOnly, immediateOrCancel, maxTs, policy, }) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getModifyOrderIx({ orderId, newDirection, newBaseAmount, newLimitPrice, newOraclePriceOffset, newTriggerPrice, newTriggerCondition, auctionDuration, auctionStartPrice, auctionEndPrice, reduceOnly, postOnly, immediateOrCancel, maxTs, policy, }, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
         });
         const orderParams = {
@@ -2656,7 +2662,7 @@ class DriftClient {
         return await this.program.instruction.modifyOrder(orderId, orderParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
             },
@@ -2681,14 +2687,14 @@ class DriftClient {
      * @param orderParams.maxTs:
      * @returns
      */
-    async modifyOrderByUserOrderId(orderParams, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getModifyOrderByUserIdIx(orderParams), txParams), [], this.opts);
+    async modifyOrderByUserOrderId(orderParams, txParams, subAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getModifyOrderByUserIdIx(orderParams, subAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getModifyOrderByUserIdIx({ userOrderId, newDirection, newBaseAmount, newLimitPrice, newOraclePriceOffset, newTriggerPrice, newTriggerCondition, auctionDuration, auctionStartPrice, auctionEndPrice, reduceOnly, postOnly, immediateOrCancel, maxTs, policy, }) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getModifyOrderByUserIdIx({ userOrderId, newDirection, newBaseAmount, newLimitPrice, newOraclePriceOffset, newTriggerPrice, newTriggerCondition, auctionDuration, auctionStartPrice, auctionEndPrice, reduceOnly, postOnly, immediateOrCancel, maxTs, policy, }, subAccountId) {
+        const user = await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
         });
         const orderParams = {
@@ -2710,7 +2716,7 @@ class DriftClient {
         return await this.program.instruction.modifyOrderByUserId(userOrderId, orderParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
             },
@@ -2752,17 +2758,17 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice), txParams), [], this.opts);
+    async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice, txParams, liquidatorSubAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice, liquidatorSubAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
-    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice) {
+    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice, liquidatorSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), userAccount],
+            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
             useMarketLastSlotCache: true,
             writablePerpMarketIndexes: [marketIndex],
         });
@@ -2772,24 +2778,24 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
-                liquidator: liquidatorPublicKey,
+                liquidator,
                 liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidateSpot(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice), txParams), [], this.opts);
+    async liquidateSpot(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, txParams, liquidatorSubAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, liquidatorSubAccountId), txParams), [], this.opts);
         this.spotMarketLastSlotCache.set(assetMarketIndex, slot);
         this.spotMarketLastSlotCache.set(liabilityMarketIndex, slot);
         return txSig;
     }
-    async getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice) {
+    async getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, liquidatorSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), userAccount],
+            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
             useMarketLastSlotCache: true,
             writableSpotMarketIndexes: [liabilityMarketIndex, assetMarketIndex],
         });
@@ -2799,24 +2805,24 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
-                liquidator: liquidatorPublicKey,
+                liquidator,
                 liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice), txParams), [], this.opts);
+    async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, txParams, liquidatorSubAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, liquidatorSubAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(perpMarketIndex, slot);
         this.spotMarketLastSlotCache.set(liabilityMarketIndex, slot);
         return txSig;
     }
-    async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice) {
+    async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, limitPrice, liquidatorSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), userAccount],
+            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
             writablePerpMarketIndexes: [perpMarketIndex],
             writableSpotMarketIndexes: [liabilityMarketIndex],
         });
@@ -2826,24 +2832,24 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
-                liquidator: liquidatorPublicKey,
+                liquidator,
                 liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer, limitPrice, txParams) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer, limitPrice), txParams), [], this.opts);
+    async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer, limitPrice, txParams, liquidatorSubAccountId) {
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer, limitPrice, liquidatorSubAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(perpMarketIndex, slot);
         this.spotMarketLastSlotCache.set(assetMarketIndex, slot);
         return txSig;
     }
-    async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer, limitPrice) {
+    async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer, limitPrice, liquidatorSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), userAccount],
+            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
             writablePerpMarketIndexes: [perpMarketIndex],
             writableSpotMarketIndexes: [assetMarketIndex],
         });
@@ -2853,22 +2859,22 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
-                liquidator: liquidatorPublicKey,
+                liquidator,
                 liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, marketIndex, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex), txParams), [], this.opts);
+    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, marketIndex, txParams, liquidatorSubAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex, liquidatorSubAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex, liquidatorSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), userAccount],
+            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
             writablePerpMarketIndexes: [marketIndex],
             writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
@@ -2879,7 +2885,7 @@ class DriftClient {
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
-                liquidator: liquidatorPublicKey,
+                liquidator,
                 liquidatorStats: liquidatorStatsPublicKey,
                 spotMarketVault: spotMarket.vault,
                 insuranceFundVault: spotMarket.insuranceFund.vault,
@@ -2889,16 +2895,16 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
-    async resolveSpotBankruptcy(userAccountPublicKey, userAccount, marketIndex, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex), txParams), [], this.opts);
+    async resolveSpotBankruptcy(userAccountPublicKey, userAccount, marketIndex, txParams, liquidatorSubAccountId) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex, liquidatorSubAccountId), txParams), [], this.opts);
         return txSig;
     }
-    async getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+    async getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex, liquidatorSubAccountId) {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const liquidator = await this.getUserAccountPublicKey(liquidatorSubAccountId);
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(), userAccount],
+            userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
             writableSpotMarketIndexes: [marketIndex],
         });
         const spotMarket = this.getSpotMarketAccount(marketIndex);
@@ -2909,7 +2915,7 @@ class DriftClient {
                 user: userAccountPublicKey,
                 userStats: userStatsPublicKey,
                 liquidatorStats: liquidatorStatsPublicKey,
-                liquidator: liquidatorPublicKey,
+                liquidator,
                 spotMarketVault: spotMarket.vault,
                 insuranceFundVault: spotMarket.insuranceFund.vault,
                 driftSigner: this.getSignerPublicKey(),