@drift-labs/sdk 0.2.0-master.30 → 0.2.0-master.32

package/lib/clearingHouse.js

@@ -266,6 +266,15 @@ class ClearingHouse {
                 isSigner: false,
             });
         }
+        const state = this.getStateAccount();
+        if (!state.whitelistMint.equals(web3_js_1.PublicKey.default)) {
+            const associatedTokenPublicKey = await spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.whitelistMint, this.wallet.publicKey);
+            remainingAccounts.push({
+                pubkey: associatedTokenPublicKey,
+                isWritable: false,
+                isSigner: false,
+            });
+        }
         const nameBuffer = (0, userName_1.encodeName)(name);
         const initializeUserAccountIx = await this.program.instruction.initializeUser(userId, nameBuffer, {
             accounts: {
@@ -330,6 +339,21 @@ class ClearingHouse {
         ]);
         return programAccounts.map((programAccount) => programAccount.account);
     }
+    async deleteUser(userId = 0) {
+        var _a;
+        const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, userId);
+        const txSig = await this.program.rpc.deleteUser({
+            accounts: {
+                user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+        await ((_a = this.users.get(userId)) === null || _a === void 0 ? void 0 : _a.unsubscribe());
+        this.users.delete(userId);
+        return txSig;
+    }
     getUser(userId) {
         userId = userId !== null && userId !== void 0 ? userId : this.activeUserId;
         if (!this.users.has(userId)) {
@@ -368,47 +392,29 @@ class ClearingHouse {
         return (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarket, spotPosition.balanceType);
     }
     getRemainingAccounts(params) {
-        const userAccountAndSlot = this.getUserAccountAndSlot();
-        if (!userAccountAndSlot) {
-            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
-        }
-        const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        const perpMarketAccountMap = new Map();
-        for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
-            // if cache has more recent slot than user positions account slot, add market to remaining accounts
-            // otherwise remove from slot
-            if (slot > lastUserPositionsSlot) {
-                const marketAccount = this.getPerpMarketAccount(marketIndexNum);
-                perpMarketAccountMap.set(marketIndexNum, {
-                    pubkey: marketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                    pubkey: marketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-            else {
-                this.marketLastSlotCache.delete(marketIndexNum);
-            }
-        }
-        for (const position of userAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const marketAccount = this.getPerpMarketAccount(position.marketIndex);
-                perpMarketAccountMap.set(position.marketIndex, {
-                    pubkey: marketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                oracleAccountMap.set(marketAccount.pubkey.toString(), {
-                    pubkey: marketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
+        var _a;
+        const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } = this.getRemainingAccountMapsForUsers(params.userAccounts);
+        if (params.useMarketLastSlotCache) {
+            const lastUserPositionsSlot = (_a = this.getUserAccountAndSlot()) === null || _a === void 0 ? void 0 : _a.slot;
+            for (const [marketIndex, slot] of this.marketLastSlotCache.entries()) {
+                // if cache has more recent slot than user positions account slot, add market to remaining accounts
+                // otherwise remove from slot
+                if (slot > lastUserPositionsSlot) {
+                    const marketAccount = this.getPerpMarketAccount(marketIndex);
+                    perpMarketAccountMap.set(marketIndex, {
+                        pubkey: marketAccount.pubkey,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                    oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                        pubkey: marketAccount.amm.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+                else {
+                    this.marketLastSlotCache.delete(marketIndex);
+                }
             }
         }
         if (params.readablePerpMarketIndex !== undefined) {
@@ -424,34 +430,19 @@ class ClearingHouse {
                 isWritable: false,
             });
         }
-        if (params.writablePerpMarketIndex !== undefined) {
-            const marketAccount = this.getPerpMarketAccount(params.writablePerpMarketIndex);
-            perpMarketAccountMap.set(params.writablePerpMarketIndex, {
-                pubkey: marketAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                pubkey: marketAccount.amm.oracle,
-                isSigner: false,
-                isWritable: false,
-            });
-        }
-        for (const spotPosition of userAccount.spotPositions) {
-            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
-                spotMarketAccountMap.set(spotPosition.marketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
+        if (params.writablePerpMarketIndexes !== undefined) {
+            for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+                const marketAccount = this.getPerpMarketAccount(writablePerpMarketIndex);
+                perpMarketAccountMap.set(writablePerpMarketIndex, {
+                    pubkey: marketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                    pubkey: marketAccount.amm.oracle,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (spotMarketAccount.marketIndex !== 0) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
             }
         }
         if (params.readableSpotMarketIndex !== undefined) {
@@ -469,19 +460,21 @@ class ClearingHouse {
                 });
             }
         }
-        if (params.writableSpotMarketIndex !== undefined) {
-            const spotMarketAccount = this.getSpotMarketAccount(params.writableSpotMarketIndex);
-            spotMarketAccountMap.set(params.writableSpotMarketIndex, {
-                pubkey: spotMarketAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            if (spotMarketAccount.marketIndex !== 0) {
-                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                    pubkey: spotMarketAccount.oracle,
+        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: false,
+                    isWritable: true,
                 });
+                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
             }
         }
         return [
@@ -490,10 +483,53 @@ class ClearingHouse {
             ...perpMarketAccountMap.values(),
         ];
     }
+    getRemainingAccountMapsForUsers(userAccounts) {
+        const oracleAccountMap = new Map();
+        const spotMarketAccountMap = new Map();
+        const perpMarketAccountMap = new Map();
+        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,
+                        });
+                    }
+                }
+            }
+            for (const position of userAccount.perpPositions) {
+                if (!(0, position_1.positionIsAvailable)(position)) {
+                    const market = this.getPerpMarketAccount(position.marketIndex);
+                    perpMarketAccountMap.set(position.marketIndex, {
+                        pubkey: market.pubkey,
+                        isWritable: false,
+                        isSigner: false,
+                    });
+                    oracleAccountMap.set(market.amm.oracle.toString(), {
+                        pubkey: market.amm.oracle,
+                        isWritable: false,
+                        isSigner: false,
+                    });
+                }
+            }
+        }
+        return {
+            oracleAccountMap,
+            spotMarketAccountMap,
+            perpMarketAccountMap,
+        };
+    }
     getOrder(orderId) {
         var _a;
-        const orderIdBN = orderId instanceof anchor_1.BN ? orderId : new anchor_1.BN(orderId);
-        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.orderId.eq(orderIdBN));
+        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.orderId === orderId);
     }
     getOrderByUserId(userOrderId) {
         var _a;
@@ -530,22 +566,15 @@ class ClearingHouse {
         let remainingAccounts = [];
         if (userInitialized) {
             remainingAccounts = this.getRemainingAccounts({
-                writableSpotMarketIndex: marketIndex,
+                userAccounts: [this.getUserAccount()],
+                useMarketLastSlotCache: true,
+                writableSpotMarketIndexes: [marketIndex],
             });
         }
         else {
-            const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-            if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                remainingAccounts.push({
-                    pubkey: spotMarketAccount.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-            remainingAccounts.push({
-                pubkey: spotMarketAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
+            remainingAccounts = this.getRemainingAccounts({
+                userAccounts: [],
+                writableSpotMarketIndexes: [marketIndex],
             });
         }
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
@@ -686,7 +715,9 @@ class ClearingHouse {
     async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         return await this.program.instruction.withdraw(marketIndex, amount, reduceOnly, {
@@ -711,9 +742,23 @@ class ClearingHouse {
     async getTransferDepositIx(amount, marketIndex, fromUserId, toUserId) {
         const fromUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, fromUserId);
         const toUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, toUserId);
-        const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
-        });
+        let remainingAccounts;
+        if (this.users.has(fromUserId)) {
+            remainingAccounts = this.getRemainingAccounts({
+                userAccounts: [this.users.get(fromUserId).getUserAccount()],
+                useMarketLastSlotCache: true,
+                writableSpotMarketIndexes: [marketIndex],
+            });
+        }
+        else {
+            const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.authority, fromUserId);
+            const fromUserAccount = (await this.program.account.user.fetch(userAccountPublicKey));
+            remainingAccounts = this.getRemainingAccounts({
+                userAccounts: [fromUserAccount],
+                useMarketLastSlotCache: true,
+                writableSpotMarketIndexes: [marketIndex],
+            });
+        }
         return await this.program.instruction.transferDeposit(marketIndex, amount, {
             accounts: {
                 authority: this.wallet.publicKey,
@@ -733,6 +778,7 @@ class ClearingHouse {
         const spotMarket = this.getSpotMarketAccount(marketIndex);
         return await this.program.instruction.updateSpotMarketCumulativeInterest({
             accounts: {
+                state: await this.getStatePublicKey(),
                 spotMarket: spotMarket.pubkey,
             },
         });
@@ -743,25 +789,10 @@ class ClearingHouse {
     }
     async settleLPIx(settleeUserAccountPublicKey, marketIndex) {
         const settleeUserAccount = (await this.program.account.user.fetch(settleeUserAccountPublicKey));
-        const userPositions = settleeUserAccount.perpPositions;
-        const remainingAccounts = [];
-        let foundMarket = false;
-        for (const position of userPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
-                remainingAccounts.push({
-                    pubkey: marketPublicKey,
-                    isWritable: true,
-                    isSigner: false,
-                });
-                if (marketIndex === position.marketIndex) {
-                    foundMarket = true;
-                }
-            }
-        }
-        if (!foundMarket) {
-            console.log('Warning: lp is not in the market specified -- tx will likely fail');
-        }
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: [marketIndex],
+        });
         return this.program.instruction.settleLp(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -777,7 +808,9 @@ class ClearingHouse {
     async getRemoveLiquidityIx(marketIndex, sharesToBurn) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writablePerpMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [marketIndex],
         });
         if (sharesToBurn == undefined) {
             const userAccount = this.getUserAccount();
@@ -802,7 +835,9 @@ class ClearingHouse {
     async getAddLiquidityIx(amount, marketIndex) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writablePerpMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [marketIndex],
         });
         return this.program.instruction.addLiquidity(amount, marketIndex, {
             accounts: {
@@ -866,6 +901,8 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
             readablePerpMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placeOrder(orderParams, {
@@ -953,7 +990,10 @@ class ClearingHouse {
     }
     async getCancelOrderIx(orderId) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccounts({});
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+        });
         return await this.program.instruction.cancelOrder(orderId !== null && orderId !== void 0 ? orderId : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -971,7 +1011,10 @@ class ClearingHouse {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const order = this.getOrderByUserId(userOrderId);
         const oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
-        const remainingAccounts = this.getRemainingAccounts({});
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+        });
         return await this.program.instruction.cancelOrderByUserId(userOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -992,59 +1035,15 @@ class ClearingHouse {
         const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         const marketIndex = order
             ? order.marketIndex
-            : userAccount.orders.find((order) => order.orderId.eq(userAccount.nextOrderId.sub(numericConstants_1.ONE))).marketIndex;
-        const marketAccount = this.getPerpMarketAccount(marketIndex);
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        const perpMarketAccountMap = new Map();
-        for (const spotPosition of userAccount.spotPositions) {
-            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
-                spotMarketAccountMap.set(spotPosition.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,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                position.marketIndex !== order.marketIndex) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                perpMarketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
+            : userAccount.orders.find((order) => order.orderId === userAccount.nextOrderId - 1).marketIndex;
+        const userAccounts = [userAccount];
+        if (makerInfo !== undefined) {
+            userAccounts.push(makerInfo.makerUserAccount);
         }
-        perpMarketAccountMap.set(marketIndex, {
-            pubkey: marketAccount.pubkey,
-            isWritable: true,
-            isSigner: false,
-        });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isWritable: false,
-            isSigner: false,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts,
+            writablePerpMarketIndexes: [marketIndex],
         });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...perpMarketAccountMap.values(),
-        ];
         if (makerInfo) {
             remainingAccounts.push({
                 pubkey: makerInfo.maker,
@@ -1091,6 +1090,8 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
             readableSpotMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placeSpotOrder(orderParams, {
@@ -1113,66 +1114,15 @@ class ClearingHouse {
         const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         const marketIndex = order
             ? order.marketIndex
-            : userAccount.orders.find((order) => order.orderId.eq(userAccount.nextOrderId.sub(numericConstants_1.ONE))).marketIndex;
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        const perpMarketAccountMap = new Map();
-        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,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                perpMarketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-        spotMarketAccountMap.set(marketIndex, {
-            pubkey: spotMarketAccount.pubkey,
-            isWritable: true,
-            isSigner: false,
-        });
-        if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-            oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                pubkey: spotMarketAccount.oracle,
-                isWritable: false,
-                isSigner: false,
-            });
+            : userAccount.orders.find((order) => order.orderId === userAccount.nextOrderId - 1).marketIndex;
+        const userAccounts = [userAccount];
+        if (makerInfo !== undefined) {
+            userAccounts.push(makerInfo.makerUserAccount);
         }
-        const quoteMarketAccount = this.getQuoteSpotMarketAccount();
-        spotMarketAccountMap.set(quoteMarketAccount.marketIndex, {
-            pubkey: quoteMarketAccount.pubkey,
-            isWritable: true,
-            isSigner: false,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts,
+            writableSpotMarketIndexes: [marketIndex, numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...perpMarketAccountMap.values(),
-        ];
         if (makerInfo) {
             remainingAccounts.push({
                 pubkey: makerInfo.maker,
@@ -1266,12 +1216,12 @@ class ClearingHouse {
                 isSigner: false,
             });
             remainingAccounts.push({
-                pubkey: spotMarketAccount.vault,
+                pubkey: this.getSpotMarketAccount(marketIndex).vault,
                 isWritable: true,
                 isSigner: false,
             });
             remainingAccounts.push({
-                pubkey: quoteMarketAccount.vault,
+                pubkey: this.getQuoteSpotMarketAccount().vault,
                 isWritable: true,
                 isSigner: false,
             });
@@ -1299,59 +1249,20 @@ class ClearingHouse {
     }
     async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
         const fillerPublicKey = await this.getUserAccountPublicKey();
-        const marketIndex = order.marketIndex;
-        const marketAccount = this.getPerpMarketAccount(marketIndex);
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        const perpMarketAccountMap = new Map();
-        for (const spotPosition of userAccount.spotPositions) {
-            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
-                spotMarketAccountMap.set(spotPosition.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,
-                    });
-                }
-            }
+        let remainingAccountsParams;
+        if ((0, types_1.isVariant)(order.marketType, 'perp')) {
+            remainingAccountsParams = {
+                userAccounts: [userAccount],
+                writablePerpMarketIndexes: [order.marketIndex],
+            };
         }
-        for (const position of userAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                position.marketIndex !== order.marketIndex) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                perpMarketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
+        else {
+            remainingAccountsParams = {
+                userAccounts: [userAccount],
+                writableSpotMarketIndexes: [order.marketIndex, numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+            };
         }
-        perpMarketAccountMap.set(marketIndex, {
-            pubkey: marketAccount.pubkey,
-            isWritable: true,
-            isSigner: false,
-        });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isWritable: false,
-            isSigner: false,
-        });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...perpMarketAccountMap.values(),
-        ];
+        const remainingAccounts = this.getRemainingAccounts(remainingAccountsParams);
         const orderId = order.orderId;
         return await this.program.instruction.triggerOrder(orderId, {
             accounts: {
@@ -1363,82 +1274,6 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async triggerSpotOrder(userAccountPublicKey, user, order) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTriggerSpotOrderIx(userAccountPublicKey, user, order)), [], this.opts);
-        return txSig;
-    }
-    async getTriggerSpotOrderIx(userAccountPublicKey, userAccount, order) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
-        const marketIndex = order.marketIndex;
-        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        const perpMarketAccountMap = new Map();
-        for (const spotPosition of userAccount.spotPositions) {
-            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
-                spotMarketAccountMap.set(spotPosition.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,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                position.marketIndex !== order.marketIndex) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                perpMarketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        const quoteSpotMarket = this.getQuoteSpotMarketAccount();
-        spotMarketAccountMap.set(quoteSpotMarket.marketIndex, {
-            pubkey: quoteSpotMarket.pubkey,
-            isWritable: true,
-            isSigner: false,
-        });
-        spotMarketAccountMap.set(marketIndex, {
-            pubkey: spotMarketAccount.pubkey,
-            isWritable: false,
-            isSigner: false,
-        });
-        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-            pubkey: spotMarketAccount.oracle,
-            isWritable: false,
-            isSigner: false,
-        });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...perpMarketAccountMap.values(),
-        ];
-        const orderId = order.orderId;
-        return await this.program.instruction.triggerSpotOrder(orderId, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-            },
-            remainingAccounts,
-        });
-    }
     async placeAndTake(orderParams, makerInfo, referrerInfo) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakeIx(orderParams, makerInfo, referrerInfo)), [], this.opts);
         this.marketLastSlotCache.set(orderParams.marketIndex, slot);
@@ -1448,9 +1283,14 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const userAccounts = [this.getUserAccount()];
+        if (makerInfo !== undefined) {
+            userAccounts.push(makerInfo.makerUserAccount);
+        }
         const remainingAccounts = this.getRemainingAccounts({
-            writablePerpMarketIndex: orderParams.marketIndex,
-            writableSpotMarketIndex: numericConstants_1.QUOTE_SPOT_MARKET_INDEX,
+            userAccounts,
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [orderParams.marketIndex],
         });
         let makerOrderId = null;
         if (makerInfo) {
@@ -1497,10 +1337,10 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        // todo merge this with getRemainingAccounts
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            counterPartyUserAccount: takerInfo.takerUserAccount,
-            writablePerpMarketIndex: orderParams.marketIndex,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [orderParams.marketIndex],
         });
         if (referrerInfo) {
             remainingAccounts.push({
@@ -1565,62 +1405,11 @@ class ClearingHouse {
         return txSig;
     }
     async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
-        const perpMarketAccountMap = new Map();
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        for (const position of settleeUserAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                perpMarketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        for (const spotPosition of settleeUserAccount.spotPositions) {
-            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                const spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
-                spotMarketAccountMap.set(spotPosition.marketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (spotMarketAccount.marketIndex !== 0) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        const marketAccount = this.getPerpMarketAccount(marketIndex);
-        perpMarketAccountMap.set(marketIndex, {
-            pubkey: marketAccount.pubkey,
-            isSigner: false,
-            isWritable: true,
-        });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isSigner: false,
-            isWritable: false,
-        });
-        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, {
-            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
-            isSigner: false,
-            isWritable: true,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: [marketIndex],
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...perpMarketAccountMap.values(),
-        ];
         return await this.program.instruction.settlePnl(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -1635,62 +1424,11 @@ class ClearingHouse {
         return txSig;
     }
     async getSettleExpiredPositionIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
-        const marketAccountMap = new Map();
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        for (const position of settleeUserAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                marketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        for (const userBankBalance of settleeUserAccount.spotPositions) {
-            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getSpotMarketAccount(userBankBalance.marketIndex);
-                spotMarketAccountMap.set(userBankBalance.marketIndex, {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (bankAccount.marketIndex !== 0) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        const marketAccount = this.getPerpMarketAccount(marketIndex);
-        marketAccountMap.set(marketIndex, {
-            pubkey: marketAccount.pubkey,
-            isSigner: false,
-            isWritable: true,
-        });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isSigner: false,
-            isWritable: false,
-        });
-        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, {
-            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
-            isSigner: false,
-            isWritable: true,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: [marketIndex],
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...marketAccountMap.values(),
-        ];
         return await this.program.instruction.settleExpiredPosition(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -1709,9 +1447,10 @@ class ClearingHouse {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            writablePerpMarketIndex: marketIndex,
-            counterPartyUserAccount: userAccount,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [marketIndex],
         });
         return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
             accounts: {
@@ -1725,22 +1464,27 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidateBorrow(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer)), [], this.opts);
+    async liquidateSpot(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer)), [], this.opts);
         return txSig;
     }
-    async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
+    async getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            counterPartyUserAccount: userAccount,
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            useMarketLastSlotCache: true,
             writableSpotMarketIndexes: [liabilityMarketIndex, assetMarketIndex],
         });
-        return await this.program.instruction.liquidateBorrow(assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, {
+        return await this.program.instruction.liquidateSpot(assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
@@ -1751,10 +1495,12 @@ class ClearingHouse {
         return txSig;
     }
     async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            counterPartyUserAccount: userAccount,
-            writablePerpMarketIndex: perpMarketIndex,
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            writablePerpMarketIndexes: [perpMarketIndex],
             writableSpotMarketIndexes: [liabilityMarketIndex],
         });
         return await this.program.instruction.liquidateBorrowForPerpPnl(perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, {
@@ -1762,7 +1508,9 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
@@ -1773,10 +1521,12 @@ class ClearingHouse {
         return txSig;
     }
     async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            counterPartyUserAccount: userAccount,
-            writablePerpMarketIndex: perpMarketIndex,
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            writablePerpMarketIndexes: [perpMarketIndex],
             writableSpotMarketIndexes: [assetMarketIndex],
         });
         return await this.program.instruction.liquidatePerpPnlForDeposit(perpMarketIndex, assetMarketIndex, maxPnlTransfer, {
@@ -1784,7 +1534,9 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
@@ -1794,11 +1546,13 @@ class ClearingHouse {
         return txSig;
     }
     async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-            writablePerpMarketIndex: marketIndex,
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            writablePerpMarketIndexes: [marketIndex],
             writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
-            counterPartyUserAccount: userAccount,
         });
         const spotMarket = this.getSpotMarketAccount(marketIndex);
         return await this.program.instruction.resolvePerpBankruptcy(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, marketIndex, {
@@ -1806,7 +1560,9 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
                 spotMarketVault: spotMarket.vault,
                 insuranceFundVault: spotMarket.insuranceFundVault,
                 clearingHouseSigner: this.getSignerPublicKey(),
@@ -1815,22 +1571,26 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async resolveBorrowBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
+    async resolveSpotBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
         return txSig;
     }
-    async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+    async getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
             writableSpotMarketIndexes: [marketIndex],
-            counterPartyUserAccount: userAccount,
         });
         const spotMarket = this.getSpotMarketAccount(marketIndex);
-        return await this.program.instruction.resolveBorrowBankruptcy(marketIndex, {
+        return await this.program.instruction.resolveSpotBankruptcy(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
                 liquidator: liquidatorPublicKey,
                 spotMarketVault: spotMarket.vault,
                 insuranceFundVault: spotMarket.insuranceFundVault,
@@ -1840,136 +1600,6 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    getRemainingAccountsWithCounterparty(params) {
-        const counterPartyUserAccount = params.counterPartyUserAccount;
-        const oracleAccountMap = new Map();
-        const spotMarketAccountMap = new Map();
-        const marketAccountMap = new Map();
-        for (const spotPosition of counterPartyUserAccount.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,
-                    });
-                }
-            }
-        }
-        for (const position of counterPartyUserAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                marketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        const userAccountAndSlot = this.getUserAccountAndSlot();
-        if (!userAccountAndSlot) {
-            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
-        }
-        const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
-        for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
-            // if cache has more recent slot than user positions account slot, add market to remaining accounts
-            // otherwise remove from slot
-            if (slot > lastUserPositionsSlot) {
-                const marketAccount = this.getPerpMarketAccount(marketIndexNum);
-                marketAccountMap.set(marketIndexNum, {
-                    pubkey: marketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                    pubkey: marketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-            else {
-                this.marketLastSlotCache.delete(marketIndexNum);
-            }
-        }
-        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,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.perpPositions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getPerpMarketAccount(position.marketIndex);
-                marketAccountMap.set(position.marketIndex, {
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        if (params.writablePerpMarketIndex !== undefined) {
-            const market = this.getPerpMarketAccount(params.writablePerpMarketIndex);
-            marketAccountMap.set(market.marketIndex, {
-                pubkey: market.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            oracleAccountMap.set(market.amm.oracle.toString(), {
-                pubkey: market.amm.oracle,
-                isSigner: false,
-                isWritable: false,
-            });
-        }
-        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,
-                    });
-                }
-            }
-        }
-        return [
-            ...oracleAccountMap.values(),
-            ...spotMarketAccountMap.values(),
-            ...marketAccountMap.values(),
-        ];
-    }
     async updateFundingRate(oracle, marketIndex) {
         const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateFundingRateIx(oracle, marketIndex)), [], this.opts);
         return txSig;
@@ -1983,28 +1613,26 @@ class ClearingHouse {
             },
         });
     }
-    async settleFundingPayment(userAccount) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleFundingPaymentIx(userAccount)), [], this.opts);
+    async settleFundingPayment(userAccountPublicKey) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleFundingPaymentIx(userAccountPublicKey)), [], this.opts);
         return txSig;
     }
-    async getSettleFundingPaymentIx(userAccount) {
-        const user = (await this.program.account.user.fetch(userAccount));
-        const userPositions = user.perpPositions;
-        const remainingAccounts = [];
-        for (const position of userPositions) {
+    async getSettleFundingPaymentIx(userAccountPublicKey) {
+        const userAccount = (await this.program.account.user.fetch(userAccountPublicKey));
+        const writablePerpMarketIndexes = [];
+        for (const position of userAccount.perpPositions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
-                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
-                remainingAccounts.push({
-                    pubkey: marketPublicKey,
-                    isWritable: false,
-                    isSigner: false,
-                });
+                writablePerpMarketIndexes.push(position.marketIndex);
             }
         }
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [userAccount],
+            writablePerpMarketIndexes,
+        });
         return await this.program.instruction.settleFundingPayment({
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccount,
+                user: userAccountPublicKey,
             },
             remainingAccounts,
         });
@@ -2045,7 +1673,9 @@ class ClearingHouse {
         const spotMarket = this.getSpotMarketAccount(marketIndex);
         const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
         return await this.program.rpc.addInsuranceFundStake(marketIndex, amount, {
             accounts: {
@@ -2054,7 +1684,9 @@ class ClearingHouse {
                 insuranceFundStake: ifStakeAccountPublicKey,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
+                spotMarketVault: spotMarket.vault,
                 insuranceFundVault: spotMarket.insuranceFundVault,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 userTokenAccount: collateralAccountPublicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
@@ -2065,7 +1697,9 @@ class ClearingHouse {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
         return await this.program.rpc.requestRemoveInsuranceFundStake(marketIndex, amount, {
             accounts: {
@@ -2075,8 +1709,6 @@ class ClearingHouse {
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
                 insuranceFundVault: spotMarketAccount.insuranceFundVault,
-                // userTokenAccount: collateralAccountPublicKey,
-                // tokenProgram: TOKEN_PROGRAM_ID,
             },
             remainingAccounts,
         });
@@ -2085,7 +1717,9 @@ class ClearingHouse {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
         return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(marketIndex, {
             accounts: {
@@ -2095,8 +1729,6 @@ class ClearingHouse {
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
                 insuranceFundVault: spotMarketAccount.insuranceFundVault,
-                // userTokenAccount: collateralAccountPublicKey,
-                // tokenProgram: TOKEN_PROGRAM_ID,
             },
             remainingAccounts,
         });
@@ -2105,7 +1737,9 @@ class ClearingHouse {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
         return await this.program.rpc.removeInsuranceFundStake(marketIndex, {
             accounts: {
@@ -2125,7 +1759,9 @@ class ClearingHouse {
     async settleRevenueToInsuranceFund(marketIndex) {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            writableSpotMarketIndex: marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
         return await this.program.rpc.settleRevenueToInsuranceFund(marketIndex, {
             accounts: {
@@ -2145,8 +1781,10 @@ class ClearingHouse {
     }
     async getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex) {
         const remainingAccounts = this.getRemainingAccounts({
-            writablePerpMarketIndex: perpMarketIndex,
-            writableSpotMarketIndex: spotMarketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [perpMarketIndex],
+            writableSpotMarketIndexes: [spotMarketIndex],
         });
         const spotMarket = this.getSpotMarketAccount(spotMarketIndex);
         return await this.program.instruction.resolvePerpPnlDeficit(spotMarketIndex, perpMarketIndex, {