@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/lib/clearingHouse.js

@@ -28,7 +28,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClearingHouse = void 0;
 const anchor_1 = require("@project-serum/anchor");
+const bs58_1 = __importDefault(require("bs58"));
 const spl_token_1 = require("@solana/spl-token");
+const types_1 = require("./types");
 const anchor = __importStar(require("@project-serum/anchor"));
 const clearing_house_json_1 = __importDefault(require("./idl/clearing_house.json"));
 const web3_js_1 = require("@solana/web3.js");
@@ -36,21 +38,23 @@ const pda_1 = require("./addresses/pda");
 const utils_1 = require("./tx/utils");
 const numericConstants_1 = require("./constants/numericConstants");
 const position_1 = require("./math/position");
-const bankBalance_1 = require("./math/bankBalance");
+const spotBalance_1 = require("./math/spotBalance");
 const userName_1 = require("./userName");
 const pollingClearingHouseAccountSubscriber_1 = require("./accounts/pollingClearingHouseAccountSubscriber");
 const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketClearingHouseAccountSubscriber");
 const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
-const orderParams_1 = require("./orderParams");
 const config_1 = require("./config");
+const spotMarkets_1 = require("./constants/spotMarkets");
+const clearingHouseUserStats_1 = require("./clearingHouseUserStats");
+const spotPosition_1 = require("./math/spotPosition");
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
  */
 class ClearingHouse {
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         this.users = new Map();
         this._isSubscribed = false;
         this.marketLastSlotCache = new Map();
@@ -59,10 +63,11 @@ class ClearingHouse {
         this.opts = config.opts || anchor_1.AnchorProvider.defaultOptions();
         this.provider = new anchor_1.AnchorProvider(config.connection, config.wallet, this.opts);
         this.program = new anchor_1.Program(clearing_house_json_1.default, config.programID, this.provider);
-        const userIds = (_a = config.userIds) !== null && _a !== void 0 ? _a : [0];
-        this.activeUserId = (_b = config.activeUserId) !== null && _b !== void 0 ? _b : userIds[0];
+        this.authority = (_a = config.authority) !== null && _a !== void 0 ? _a : this.wallet.publicKey;
+        const userIds = (_b = config.userIds) !== null && _b !== void 0 ? _b : [0];
+        this.activeUserId = (_c = config.activeUserId) !== null && _c !== void 0 ? _c : userIds[0];
         this.userAccountSubscriptionConfig =
-            ((_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.type) === 'polling'
+            ((_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.type) === 'polling'
                 ? {
                     type: 'polling',
                     accountLoader: config.accountSubscription.accountLoader,
@@ -71,23 +76,34 @@ class ClearingHouse {
                     type: 'websocket',
                 };
         this.createUsers(userIds, this.userAccountSubscriptionConfig);
-        let marketIndexes = config.marketIndexes;
-        let bankIndexes = config.bankIndexes;
+        if (config.userStats) {
+            this.userStats = new clearingHouseUserStats_1.ClearingHouseUserStats({
+                clearingHouse: this,
+                userStatsAccountPublicKey: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.authority),
+                accountSubscription: this.userAccountSubscriptionConfig,
+            });
+        }
+        let perpMarketIndexes = config.perpMarketIndexes;
+        let spotMarketIndexes = config.spotMarketIndexes;
         let oracleInfos = config.oracleInfos;
         if (config.env) {
-            const { marketIndexes: envMarketIndexes, bankIndexes: envBankIndexes, oracleInfos: envOralceInfos, } = (0, config_1.getMarketsBanksAndOraclesForSubscription)(config.env);
-            marketIndexes = marketIndexes ? marketIndexes : envMarketIndexes;
-            bankIndexes = bankIndexes ? bankIndexes : envBankIndexes;
+            const { perpMarketIndexes: envPerpMarketIndexes, spotMarketIndexes: envSpotMarketIndexes, oracleInfos: envOralceInfos, } = (0, config_1.getMarketsAndOraclesForSubscription)(config.env);
+            perpMarketIndexes = perpMarketIndexes
+                ? perpMarketIndexes
+                : envPerpMarketIndexes;
+            spotMarketIndexes = spotMarketIndexes
+                ? spotMarketIndexes
+                : envSpotMarketIndexes;
             oracleInfos = oracleInfos ? oracleInfos : envOralceInfos;
         }
-        if (((_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.type) === 'polling') {
-            this.accountSubscriber = new pollingClearingHouseAccountSubscriber_1.PollingClearingHouseAccountSubscriber(this.program, config.accountSubscription.accountLoader, marketIndexes !== null && marketIndexes !== void 0 ? marketIndexes : [], bankIndexes !== null && bankIndexes !== void 0 ? bankIndexes : [], oracleInfos !== null && oracleInfos !== void 0 ? oracleInfos : []);
+        if (((_e = config.accountSubscription) === null || _e === void 0 ? void 0 : _e.type) === 'polling') {
+            this.accountSubscriber = new pollingClearingHouseAccountSubscriber_1.PollingClearingHouseAccountSubscriber(this.program, config.accountSubscription.accountLoader, perpMarketIndexes !== null && perpMarketIndexes !== void 0 ? perpMarketIndexes : [], spotMarketIndexes !== null && spotMarketIndexes !== void 0 ? spotMarketIndexes : [], oracleInfos !== null && oracleInfos !== void 0 ? oracleInfos : []);
         }
         else {
-            this.accountSubscriber = new webSocketClearingHouseAccountSubscriber_1.WebSocketClearingHouseAccountSubscriber(this.program, (_e = config.marketIndexes) !== null && _e !== void 0 ? _e : [], (_f = config.bankIndexes) !== null && _f !== void 0 ? _f : [], (_g = config.oracleInfos) !== null && _g !== void 0 ? _g : []);
+            this.accountSubscriber = new webSocketClearingHouseAccountSubscriber_1.WebSocketClearingHouseAccountSubscriber(this.program, (_f = config.perpMarketIndexes) !== null && _f !== void 0 ? _f : [], (_g = config.spotMarketIndexes) !== null && _g !== void 0 ? _g : [], (_h = config.oracleInfos) !== null && _h !== void 0 ? _h : []);
         }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
-        this.txSender = new retryTxSender_1.RetryTxSender(this.provider, (_h = config.txSenderConfig) === null || _h === void 0 ? void 0 : _h.timeout, (_j = config.txSenderConfig) === null || _j === void 0 ? void 0 : _j.retrySleep, (_k = config.txSenderConfig) === null || _k === void 0 ? void 0 : _k.additionalConnections);
+        this.txSender = new retryTxSender_1.RetryTxSender(this.provider, (_j = config.txSenderConfig) === null || _j === void 0 ? void 0 : _j.timeout, (_k = config.txSenderConfig) === null || _k === void 0 ? void 0 : _k.retrySleep, (_l = config.txSenderConfig) === null || _l === void 0 ? void 0 : _l.additionalConnections);
     }
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -102,7 +118,7 @@ class ClearingHouse {
         }
     }
     createUser(userId, accountSubscriptionConfig) {
-        const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, userId);
+        const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.authority, userId);
         return new clearingHouseUser_1.ClearingHouseUser({
             clearingHouse: this,
             userAccountPublicKey,
@@ -111,6 +127,9 @@ class ClearingHouse {
     }
     async subscribe() {
         const subscribePromises = this.subscribeUsers().concat(this.accountSubscriber.subscribe());
+        if (this.userStats !== undefined) {
+            subscribePromises.concat(this.userStats.subscribe());
+        }
         this.isSubscribed = (await Promise.all(subscribePromises)).reduce((success, prevSuccess) => success && prevSuccess);
         return this.isSubscribed;
     }
@@ -121,12 +140,19 @@ class ClearingHouse {
      *	Forces the accountSubscriber to fetch account updates from rpc
      */
     async fetchAccounts() {
-        await Promise.all([...this.users.values()]
+        const promises = [...this.users.values()]
             .map((user) => user.fetchAccounts())
-            .concat(this.accountSubscriber.fetch()));
+            .concat(this.accountSubscriber.fetch());
+        if (this.userStats) {
+            promises.concat(this.userStats.fetchAccounts());
+        }
+        await Promise.all(promises);
     }
     async unsubscribe() {
         const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
+        if (this.userStats !== undefined) {
+            unsubscribePromises.concat(this.userStats.unsubscribe());
+        }
         await Promise.all(unsubscribePromises);
         this.isSubscribed = false;
     }
@@ -140,30 +166,43 @@ class ClearingHouse {
         this.statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
         return this.statePublicKey;
     }
+    getSignerPublicKey() {
+        if (this.signerPublicKey) {
+            return this.signerPublicKey;
+        }
+        this.signerPublicKey = (0, pda_1.getClearingHouseSignerPublicKey)(this.program.programId);
+        return this.signerPublicKey;
+    }
     getStateAccount() {
         return this.accountSubscriber.getStateAccountAndSlot().data;
     }
-    getMarketAccount(marketIndex) {
+    getPerpMarketAccount(marketIndex) {
         var _a;
-        marketIndex = marketIndex instanceof anchor_1.BN ? marketIndex : new anchor_1.BN(marketIndex);
         return (_a = this.accountSubscriber.getMarketAccountAndSlot(marketIndex)) === null || _a === void 0 ? void 0 : _a.data;
     }
-    getMarketAccounts() {
+    getPerpMarketAccounts() {
         return this.accountSubscriber
             .getMarketAccountsAndSlots()
             .map((value) => value.data);
     }
-    getBankAccount(bankIndex) {
-        bankIndex = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
-        return this.accountSubscriber.getBankAccountAndSlot(bankIndex).data;
+    getSpotMarketAccount(marketIndex) {
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
     }
-    getQuoteAssetBankAccount() {
-        return this.accountSubscriber.getBankAccountAndSlot(numericConstants_1.QUOTE_ASSET_BANK_INDEX)
-            .data;
+    getSpotMarketAccounts() {
+        return this.accountSubscriber
+            .getSpotMarketAccountsAndSlots()
+            .map((value) => value.data);
+    }
+    getQuoteSpotMarketAccount() {
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).data;
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         return this.accountSubscriber.getOraclePriceDataAndSlot(oraclePublicKey);
     }
+    async getSerumV3FulfillmentConfig(serumMarket) {
+        const address = await (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
+        return (await this.program.account.serumV3FulfillmentConfig.fetch(address));
+    }
     /**
      * Update the wallet to use for clearing house transactions and linked user account
      * @param newWallet
@@ -178,6 +217,7 @@ class ClearingHouse {
         this.wallet = newWallet;
         this.provider = newProvider;
         this.program = newProgram;
+        this.authority = newWallet.publicKey;
         if (this.isSubscribed) {
             await Promise.all(this.unsubscribeUsers());
         }
@@ -187,6 +227,7 @@ class ClearingHouse {
             await Promise.all(this.subscribeUsers());
         }
         this.activeUserId = activeUserId;
+        this.userStatsAccountPublicKey = undefined;
     }
     async switchActiveUser(userId) {
         this.activeUserId = userId;
@@ -199,27 +240,120 @@ class ClearingHouse {
         await user.subscribe();
         this.users.set(userId, user);
     }
-    async initializeUserAccount(userId = 0, name = userName_1.DEFAULT_USER_NAME) {
-        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
-        const tx = new web3_js_1.Transaction().add(initializeUserAccountIx);
+    async initializeUserAccount(userId = 0, name = userName_1.DEFAULT_USER_NAME, referrerInfo) {
+        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name, referrerInfo);
+        const tx = new web3_js_1.Transaction();
+        if (userId === 0) {
+            // not the safest assumption, can explicitly check if user stats account exists if it causes problems
+            tx.add(await this.getInitializeUserStatsIx());
+        }
+        tx.add(initializeUserAccountIx);
         const { txSig } = await this.txSender.send(tx, [], this.opts);
         return [txSig, userAccountPublicKey];
     }
-    async getInitializeUserInstructions(userId = 0, name = userName_1.DEFAULT_USER_NAME) {
+    async getInitializeUserInstructions(userId = 0, name = userName_1.DEFAULT_USER_NAME, referrerInfo) {
         const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId);
+        const remainingAccounts = new Array();
+        if (referrerInfo !== undefined) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                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: {
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
                 payer: this.wallet.publicKey,
                 rent: anchor.web3.SYSVAR_RENT_PUBKEY,
                 systemProgram: anchor.web3.SystemProgram.programId,
                 state: await this.getStatePublicKey(),
             },
+            remainingAccounts,
         });
         return [userAccountPublicKey, initializeUserAccountIx];
     }
+    async getInitializeUserStatsIx() {
+        return await this.program.instruction.initializeUserStats({
+            accounts: {
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                payer: this.wallet.publicKey,
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateUserName(name, userId = 0) {
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        return await this.program.rpc.updateUserName(userId, nameBuffer, {
+            accounts: {
+                user: await this.getUserAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+        });
+    }
+    async updateUserCustomMarginRatio(marginRatio, userId = 0) {
+        return await this.program.rpc.updateUserCustomMarginRatio(userId, marginRatio, {
+            accounts: {
+                user: await this.getUserAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+        });
+    }
+    async updateUserDelegate(delegate, userId = 0) {
+        return await this.program.rpc.updateUserDelegate(userId, delegate, {
+            accounts: {
+                user: await this.getUserAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+        });
+    }
+    async getUserAccountsForDelegate(delegate) {
+        const programAccounts = await this.program.account.user.all([
+            {
+                memcmp: {
+                    offset: 40,
+                    /** data to match, as base-58 encoded string and limited to less than 129 bytes */
+                    bytes: bs58_1.default.encode(delegate.toBuffer()),
+                },
+            },
+        ]);
+        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)) {
@@ -230,6 +364,16 @@ class ClearingHouse {
     getUsers() {
         return [...this.users.values()];
     }
+    getUserStats() {
+        return this.userStats;
+    }
+    getUserStatsAccountPublicKey() {
+        if (this.userStatsAccountPublicKey) {
+            return this.userStatsAccountPublicKey;
+        }
+        this.userStatsAccountPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.authority);
+        return this.userStatsAccountPublicKey;
+    }
     async getUserAccountPublicKey() {
         return this.getUser().userAccountPublicKey;
     }
@@ -239,153 +383,208 @@ class ClearingHouse {
     getUserAccountAndSlot(userId) {
         return this.getUser(userId).getUserAccountAndSlot();
     }
-    getUserBankBalance(bankIndex) {
-        const bankIndexBN = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
-        return this.getUserAccount().bankBalances.find((bankBalance) => bankBalance.bankIndex.eq(bankIndexBN));
+    getSpotPosition(marketIndex) {
+        return this.getUserAccount().spotPositions.find((spotPosition) => spotPosition.marketIndex === marketIndex);
     }
     getQuoteAssetTokenAmount() {
-        const bank = this.getBankAccount(numericConstants_1.QUOTE_ASSET_BANK_INDEX);
-        const userBankBalance = this.getUserBankBalance(numericConstants_1.QUOTE_ASSET_BANK_INDEX);
-        return (0, bankBalance_1.getTokenAmount)(userBankBalance.balance, bank, userBankBalance.balanceType);
+        const spotMarket = this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        const spotPosition = this.getSpotPosition(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        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 bankAccountMap = new Map();
-        const marketAccountMap = 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.getMarketAccount(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);
+        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);
+                }
             }
         }
-        for (const position of userAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const marketIndexNum = position.marketIndex.toNumber();
-                const marketAccount = this.getMarketAccount(marketIndexNum);
-                marketAccountMap.set(marketIndexNum, {
+        if (params.readablePerpMarketIndex !== undefined) {
+            const marketAccount = this.getPerpMarketAccount(params.readablePerpMarketIndex);
+            perpMarketAccountMap.set(params.readablePerpMarketIndex, {
+                pubkey: marketAccount.pubkey,
+                isSigner: false,
+                isWritable: false,
+            });
+            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                pubkey: marketAccount.amm.oracle,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
+        if (params.writablePerpMarketIndexes !== undefined) {
+            for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+                const marketAccount = this.getPerpMarketAccount(writablePerpMarketIndex);
+                perpMarketAccountMap.set(writablePerpMarketIndex, {
                     pubkey: marketAccount.pubkey,
                     isSigner: false,
-                    // isWritable: false, // TODO
                     isWritable: true,
                 });
-                oracleAccountMap.set(marketAccount.pubkey.toString(), {
+                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
                     pubkey: marketAccount.amm.oracle,
                     isSigner: false,
                     isWritable: false,
                 });
             }
         }
-        if (params.writableMarketIndex) {
-            const marketAccount = this.getMarketAccount(params.writableMarketIndex.toNumber());
-            marketAccountMap.set(params.writableMarketIndex.toNumber(), {
-                pubkey: marketAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                pubkey: marketAccount.amm.oracle,
+        if (params.readableSpotMarketIndex !== undefined) {
+            const spotMarketAccount = this.getSpotMarketAccount(params.readableSpotMarketIndex);
+            spotMarketAccountMap.set(params.readableSpotMarketIndex, {
+                pubkey: spotMarketAccount.pubkey,
                 isSigner: false,
                 isWritable: false,
             });
-        }
-        for (const userBankBalance of userAccount.bankBalances) {
-            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
+            if (spotMarketAccount.marketIndex !== 0) {
+                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                    pubkey: spotMarketAccount.oracle,
                     isSigner: false,
                     isWritable: false,
                 });
-                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
             }
         }
-        if (params.writableBankIndex) {
-            const bankAccount = this.getBankAccount(params.writableBankIndex);
-            bankAccountMap.set(params.writableBankIndex.toNumber(), {
-                pubkey: bankAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                oracleAccountMap.set(bankAccount.oracle.toString(), {
-                    pubkey: bankAccount.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 [
             ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
+            ...spotMarketAccountMap.values(),
+            ...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;
         return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.userOrderId === userOrderId);
     }
-    async deposit(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly = false) {
-        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly, true);
-        const tx = new web3_js_1.Transaction().add(depositCollateralIx);
-        const { txSig } = await this.txSender.send(tx);
+    async deposit(amount, marketIndex, collateralAccountPublicKey, userId, reduceOnly = false) {
+        const tx = new web3_js_1.Transaction();
+        const additionalSigners = [];
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
+        const authority = this.authority;
+        const createWSOLTokenAccount = isSolMarket && collateralAccountPublicKey.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount, true);
+            collateralAccountPublicKey = pubkey;
+            ixs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
+        const depositCollateralIx = await this.getDepositInstruction(amount, marketIndex, collateralAccountPublicKey, userId, reduceOnly, true);
+        tx.add(depositCollateralIx);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, collateralAccountPublicKey, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
-    async getDepositInstruction(amount, bankIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
+    async getDepositInstruction(amount, marketIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
         const userAccountPublicKey = userId
-            ? await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId)
+            ? await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.authority, userId)
             : await this.getUserAccountPublicKey();
         let remainingAccounts = [];
         if (userInitialized) {
             remainingAccounts = this.getRemainingAccounts({
-                writableBankIndex: bankIndex,
+                userAccounts: [this.getUserAccount()],
+                useMarketLastSlotCache: true,
+                writableSpotMarketIndexes: [marketIndex],
             });
         }
         else {
-            remainingAccounts = [
-                {
-                    pubkey: this.getBankAccount(bankIndex).pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                },
-            ];
+            remainingAccounts = this.getRemainingAccounts({
+                userAccounts: [],
+                writableSpotMarketIndexes: [marketIndex],
+            });
         }
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.deposit(bankIndex, amount, reduceOnly, {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.deposit(marketIndex, amount, reduceOnly, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
-                bankVault: bank.vault,
+                spotMarket: spotMarketAccount.pubkey,
+                spotMarketVault: spotMarketAccount.vault,
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 userTokenAccount: userTokenAccount,
                 authority: this.wallet.publicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
@@ -393,55 +592,142 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async checkIfAccountExists(account) {
+        try {
+            const accountInfo = await this.connection.getAccountInfo(account);
+            return accountInfo != null;
+        }
+        catch (e) {
+            // Doesn't already exist
+            return false;
+        }
+    }
+    async getWrappedSolAccountCreationIxs(amount, isDeposit) {
+        const wrappedSolAccount = new web3_js_1.Keypair();
+        const result = {
+            ixs: [],
+            signers: [],
+            pubkey: wrappedSolAccount.publicKey,
+        };
+        const rentSpaceLamports = new anchor_1.BN(web3_js_1.LAMPORTS_PER_SOL / 100);
+        const lamports = isDeposit
+            ? amount.add(rentSpaceLamports)
+            : rentSpaceLamports;
+        const authority = this.wallet.publicKey;
+        result.ixs.push(web3_js_1.SystemProgram.createAccount({
+            fromPubkey: authority,
+            newAccountPubkey: wrappedSolAccount.publicKey,
+            lamports: lamports.toNumber(),
+            space: 165,
+            programId: spl_token_1.TOKEN_PROGRAM_ID,
+        }));
+        result.ixs.push(spl_token_1.Token.createInitAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, spotMarkets_1.WRAPPED_SOL_MINT, wrappedSolAccount.publicKey, authority));
+        result.signers.push(wrappedSolAccount);
+        return result;
+    }
+    getAssociatedTokenAccountCreationIx(tokenMintAddress, associatedTokenAddress) {
+        const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, tokenMintAddress, associatedTokenAddress, this.wallet.publicKey, this.wallet.publicKey);
+        return createAssociatedAccountIx;
+    }
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
      * @param amount
      * @param userTokenAccount
+     * @param marketIndex
+     * @param userId
+     * @param name
      * @param fromUserId
      * @returns
      */
-    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, bankIndex = new anchor_1.BN(0), userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId) {
-        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
+    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId, referrerInfo) {
+        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name, referrerInfo);
+        const additionalSigners = [];
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const isSolMarket = spotMarket.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
+        const tx = new web3_js_1.Transaction();
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolMarket && userTokenAccount.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs: startIxs, signers, pubkey, } = await this.getWrappedSolAccountCreationIxs(amount, true);
+            userTokenAccount = pubkey;
+            startIxs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
         const depositCollateralIx = fromUserId != null
-            ? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
-            : await this.getDepositInstruction(amount, bankIndex, userTokenAccount, userId, false, false);
-        const tx = new web3_js_1.Transaction()
-            .add(initializeUserAccountIx)
-            .add(depositCollateralIx);
-        const { txSig } = await this.txSender.send(tx, []);
+            ? await this.getTransferDepositIx(amount, marketIndex, fromUserId, userId)
+            : await this.getDepositInstruction(amount, marketIndex, userTokenAccount, userId, false, false);
+        if (userId === 0) {
+            tx.add(await this.getInitializeUserStatsIx());
+        }
+        tx.add(initializeUserAccountIx).add(depositCollateralIx);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return [txSig, userAccountPublicKey];
     }
-    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, mockUSDCFaucet, amount) {
-        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
-        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
-        const depositCollateralIx = await this.getDepositInstruction(amount, new anchor_1.BN(0), associateTokenPublicKey, userId, false, false);
-        const tx = new web3_js_1.Transaction()
-            .add(createAssociatedAccountIx)
-            .add(mintToIx)
-            .add(initializeUserAccountIx)
-            .add(depositCollateralIx);
+    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo) {
+        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
+        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name, referrerInfo);
+        const depositCollateralIx = await this.getDepositInstruction(amount, marketIndex, associateTokenPublicKey, userId, false, false);
+        const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToIx);
+        if (userId === 0) {
+            tx.add(await this.getInitializeUserStatsIx());
+        }
+        tx.add(initializeUserAccountIx).add(depositCollateralIx);
         const txSig = await this.program.provider.sendAndConfirm(tx, []);
         return [txSig, userAccountPublicKey];
     }
-    async withdraw(amount, bankIndex, userTokenAccount, reduceOnly = false) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly)), [], this.opts);
+    async withdraw(amount, marketIndex, userTokenAccount, reduceOnly = false) {
+        const tx = new web3_js_1.Transaction();
+        const additionalSigners = [];
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolMarket && userTokenAccount.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount, false);
+            userTokenAccount = pubkey;
+            ixs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
+        else {
+            const accountExists = await this.checkIfAccountExists(userTokenAccount);
+            if (!accountExists) {
+                const createAssociatedTokenAccountIx = this.getAssociatedTokenAccountCreationIx(spotMarketAccount.mint, userTokenAccount);
+                tx.add(createAssociatedTokenAccountIx);
+            }
+        }
+        const withdrawCollateral = await this.getWithdrawIx(amount, spotMarketAccount.marketIndex, userTokenAccount, reduceOnly);
+        tx.add(withdrawCollateral);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
-    async getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly = false) {
+    async getWithdrawIx(amount, marketIndex, userTokenAccount, reduceOnly = false) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableBankIndex: bankIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
         });
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.withdraw(bankIndex, amount, reduceOnly, {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.withdraw(marketIndex, amount, reduceOnly, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                bank: bank.pubkey,
-                bankVault: bank.vault,
-                bankVaultAuthority: bank.vaultAuthority,
+                spotMarket: spotMarketAccount.pubkey,
+                spotMarketVault: spotMarketAccount.vault,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 userTokenAccount: userTokenAccount,
                 authority: this.wallet.publicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
@@ -449,55 +735,181 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async transferDeposit(amount, bankIndex, fromUserId, toUserId) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, bankIndex, fromUserId, toUserId)), [], this.opts);
+    async transferDeposit(amount, marketIndex, fromUserId, toUserId) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, marketIndex, fromUserId, toUserId)), [], this.opts);
         return txSig;
     }
-    async getTransferDepositIx(amount, bankIndex, fromUserId, toUserId) {
+    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({
-            writableBankIndex: bankIndex,
-        });
-        return await this.program.instruction.transferDeposit(bankIndex, amount, {
+        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,
                 fromUser,
                 toUser,
+                userStats: this.getUserStatsAccountPublicKey(),
                 state: await this.getStatePublicKey(),
             },
             remainingAccounts,
         });
     }
-    async updateBankCumulativeInterest(bankIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.updateBankCumulativeInterestIx(bankIndex)), [], this.opts);
+    async updateSpotMarketCumulativeInterest(marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.updateSpotMarketCumulativeInterestIx(marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async updateSpotMarketCumulativeInterestIx(marketIndex) {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.updateSpotMarketCumulativeInterest({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarket.pubkey,
+            },
+        });
+    }
+    async settleLP(settleeUserAccountPublicKey, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.settleLPIx(settleeUserAccountPublicKey, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async settleLPIx(settleeUserAccountPublicKey, marketIndex) {
+        const settleeUserAccount = (await this.program.account.user.fetch(settleeUserAccountPublicKey));
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: [marketIndex],
+        });
+        return this.program.instruction.settleLp(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: settleeUserAccountPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async removeLiquidity(marketIndex, sharesToBurn) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)), [], this.opts);
+        return txSig;
+    }
+    async getRemoveLiquidityIx(marketIndex, sharesToBurn) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [marketIndex],
+        });
+        if (sharesToBurn == undefined) {
+            const userAccount = this.getUserAccount();
+            const perpPosition = userAccount.perpPositions.filter((position) => position.marketIndex === marketIndex)[0];
+            sharesToBurn = perpPosition.lpShares;
+            console.log('burning lp shares:', sharesToBurn.toString());
+        }
+        return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async addLiquidity(amount, marketIndex) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getAddLiquidityIx(amount, marketIndex)), [], this.opts);
+        this.marketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
-    async updateBankCumulativeInterestIx(bankIndex) {
-        const bank = this.getBankAccount(bankIndex);
-        return await this.program.instruction.updateBankCumulativeInterest({
+    async getAddLiquidityIx(amount, marketIndex) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [marketIndex],
+        });
+        return this.program.instruction.addLiquidity(amount, marketIndex, {
             accounts: {
-                bank: bank.pubkey,
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
             },
+            remainingAccounts: remainingAccounts,
         });
     }
     async openPosition(direction, amount, marketIndex, limitPrice) {
-        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, direction, numericConstants_1.ZERO, amount, false, limitPrice));
+        return await this.placeAndTake({
+            orderType: types_1.OrderType.MARKET,
+            marketIndex,
+            direction,
+            baseAssetAmount: amount,
+            price: limitPrice,
+        });
+    }
+    async sendSignedTx(tx) {
+        const { txSig } = await this.txSender.send(tx, undefined, this.opts, true);
+        return txSig;
+    }
+    /**
+     * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
+     * @param orderParams
+     * @param userAccountPublicKey
+     * @param userAccount
+     * @returns
+     */
+    async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount) {
+        const marketIndex = orderParams.marketIndex;
+        const orderId = userAccount.nextOrderId;
+        const marketOrderTx = (0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams));
+        const fillTx = (0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, userAccount, {
+            orderId,
+            marketIndex,
+        }));
+        // Apply the latest blockhash to the txs so that we can sign before sending them
+        const currentBlockHash = (await this.connection.getLatestBlockhash('finalized')).blockhash;
+        marketOrderTx.recentBlockhash = currentBlockHash;
+        fillTx.recentBlockhash = currentBlockHash;
+        marketOrderTx.feePayer = userAccount.authority;
+        fillTx.feePayer = userAccount.authority;
+        const [signedMarketOrderTx, signedFillTx] = await this.provider.wallet.signAllTransactions([marketOrderTx, fillTx]);
+        const { txSig, slot } = await this.txSender.send(signedMarketOrderTx, [], this.opts, true);
+        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+        return { txSig, signedFillTx };
     }
     async placeOrder(orderParams) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams)), [], this.opts);
-        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
+    getOrderParams(optionalOrderParams, marketType) {
+        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams, {
+            marketType,
+        });
+    }
     async getPlaceOrderIx(orderParams) {
+        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: orderParams.marketIndex,
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            readablePerpMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placeOrder(orderParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -509,13 +921,13 @@ class ClearingHouse {
     }
     async getUpdateAMMsIx(marketIndexes) {
         for (let i = marketIndexes.length; i < 5; i++) {
-            marketIndexes.push(new anchor_1.BN(100));
+            marketIndexes.push(100);
         }
         const marketAccountInfos = [];
         const oracleAccountInfos = [];
         for (const marketIndex of marketIndexes) {
-            if (!marketIndex.eq(new anchor_1.BN(100))) {
-                const market = this.getMarketAccount(marketIndex);
+            if (marketIndex !== 100) {
+                const market = this.getPerpMarketAccount(marketIndex);
                 marketAccountInfos.push({
                     pubkey: market.pubkey,
                     isWritable: true,
@@ -537,13 +949,51 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async settleExpiredMarket(marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleExpiredMarketIx(marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getSettleExpiredMarketIx(marketIndex) {
+        const marketAccountInfos = [];
+        const oracleAccountInfos = [];
+        const spotMarketAccountInfos = [];
+        const market = this.getPerpMarketAccount(marketIndex);
+        marketAccountInfos.push({
+            pubkey: market.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        oracleAccountInfos.push({
+            pubkey: market.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        spotMarketAccountInfos.push({
+            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
+            isSigner: false,
+            isWritable: true,
+        });
+        const remainingAccounts = oracleAccountInfos
+            .concat(spotMarketAccountInfos)
+            .concat(marketAccountInfos);
+        return await this.program.instruction.settleExpiredMarket(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async cancelOrder(orderId) {
         const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrderIx(orderId)), [], this.opts);
         return txSig;
     }
     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(),
@@ -560,8 +1010,11 @@ class ClearingHouse {
     async getCancelOrderByUserIdIx(userOrderId) {
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const order = this.getOrderByUserId(userOrderId);
-        const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-        const remainingAccounts = this.getRemainingAccounts({});
+        const oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+        });
         return await this.program.instruction.cancelOrderByUserId(userOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
@@ -572,55 +1025,45 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async fillOrder(userAccountPublicKey, user, order, makerInfo) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)), [], this.opts);
+    async fillOrder(userAccountPublicKey, user, order, makerInfo, referrerInfo) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo)), [], this.opts);
         return txSig;
     }
-    async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo) {
+    async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo, referrerInfo) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const fillerPublicKey = await this.getUserAccountPublicKey();
-        const marketIndex = order.marketIndex;
-        const marketAccount = this.getMarketAccount(marketIndex);
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
-            },
-        ];
-        const marketAccountInfos = [
-            {
-                pubkey: marketAccount.pubkey,
+        const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const marketIndex = order
+            ? order.marketIndex
+            : userAccount.orders.find((order) => order.orderId === userAccount.nextOrderId - 1).marketIndex;
+        const userAccounts = [userAccount];
+        if (makerInfo !== undefined) {
+            userAccounts.push(makerInfo.makerUserAccount);
+        }
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts,
+            writablePerpMarketIndexes: [marketIndex],
+        });
+        if (makerInfo) {
+            remainingAccounts.push({
+                pubkey: makerInfo.maker,
                 isWritable: true,
                 isSigner: false,
-            },
-        ];
-        const oracleAccountInfos = [
-            {
-                pubkey: marketAccount.amm.oracle,
-                isWritable: false,
+            });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isWritable: true,
                 isSigner: false,
-            },
-        ];
-        for (const position of userAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                !position.marketIndex.eq(order.marketIndex)) {
-                const market = this.getMarketAccount(position.marketIndex);
-                marketAccountInfos.push({
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountInfos.push({
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
+            });
         }
-        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
-        if (makerInfo) {
+        if (referrerInfo) {
             remainingAccounts.push({
-                pubkey: makerInfo.maker,
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
                 isWritable: true,
                 isSigner: false,
             });
@@ -631,58 +1074,195 @@ class ClearingHouse {
             accounts: {
                 state: await this.getStatePublicKey(),
                 filler: fillerPublicKey,
+                fillerStats: fillerStatsPublicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
         });
     }
-    async triggerOrder(userAccountPublicKey, user, order) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTriggerOrderIx(userAccountPublicKey, user, order)), [], this.opts);
+    async placeSpotOrder(orderParams) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceSpotOrderIx(orderParams)), [], this.opts);
         return txSig;
     }
-    async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
+    async getPlaceSpotOrderIx(orderParams) {
+        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, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
+    async fillSpotOrder(userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillSpotOrderIx(userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo)), [], this.opts);
+        return txSig;
+    }
+    async getFillSpotOrderIx(userAccountPublicKey, userAccount, order, fulfillmentConfig, makerInfo, referrerInfo) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const fillerPublicKey = await this.getUserAccountPublicKey();
-        const marketIndex = order.marketIndex;
-        const marketAccount = this.getMarketAccount(marketIndex);
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
+        const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const marketIndex = order
+            ? order.marketIndex
+            : userAccount.orders.find((order) => order.orderId === userAccount.nextOrderId - 1).marketIndex;
+        const userAccounts = [userAccount];
+        if (makerInfo !== undefined) {
+            userAccounts.push(makerInfo.makerUserAccount);
+        }
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts,
+            writableSpotMarketIndexes: [marketIndex, numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+        });
+        if (makerInfo) {
+            remainingAccounts.push({
+                pubkey: makerInfo.maker,
+                isWritable: true,
                 isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
                 isWritable: true,
-            },
-        ];
-        const marketAccountInfos = [
-            {
-                pubkey: marketAccount.pubkey,
+                isSigner: false,
+            });
+        }
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
                 isWritable: true,
                 isSigner: false,
-            },
-        ];
-        const oracleAccountInfos = [
-            {
-                pubkey: marketAccount.amm.oracle,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        const orderId = order.orderId;
+        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+        if (fulfillmentConfig) {
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.pubkey,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumProgramId,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumMarket,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumRequestQueue,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumEventQueue,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumBids,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumAsks,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumBaseVault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumQuoteVault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: fulfillmentConfig.serumOpenOrders,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: (0, pda_1.getSerumSignerPublicKey)(fulfillmentConfig.serumProgramId, fulfillmentConfig.serumMarket, fulfillmentConfig.serumSignerNonce),
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.getSignerPublicKey(),
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: spl_token_1.TOKEN_PROGRAM_ID,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.getSpotMarketAccount(marketIndex).vault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.getQuoteSpotMarketAccount().vault,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.getStateAccount().srmVault,
                 isWritable: false,
                 isSigner: false,
+            });
+        }
+        return await this.program.instruction.fillSpotOrder(orderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                fillerStats: fillerStatsPublicKey,
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                authority: this.wallet.publicKey,
             },
-        ];
-        for (const position of userAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                !position.marketIndex.eq(order.marketIndex)) {
-                const market = this.getMarketAccount(position.marketIndex);
-                marketAccountInfos.push({
-                    pubkey: market.pubkey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-                oracleAccountInfos.push({
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
+            remainingAccounts,
+        });
+    }
+    async triggerOrder(userAccountPublicKey, user, order) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTriggerOrderIx(userAccountPublicKey, user, order)), [], this.opts);
+        return txSig;
+    }
+    async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        let remainingAccountsParams;
+        if ((0, types_1.isVariant)(order.marketType, 'perp')) {
+            remainingAccountsParams = {
+                userAccounts: [userAccount],
+                writablePerpMarketIndexes: [order.marketIndex],
+            };
+        }
+        else {
+            remainingAccountsParams = {
+                userAccounts: [userAccount],
+                writableSpotMarketIndexes: [order.marketIndex, numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+            };
         }
-        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
+        const remainingAccounts = this.getRemainingAccounts(remainingAccountsParams);
         const orderId = order.orderId;
         return await this.program.instruction.triggerOrder(orderId, {
             accounts: {
@@ -694,16 +1274,23 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
-    async placeAndTake(orderParams, makerInfo) {
-        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakeIx(orderParams, makerInfo)), [], this.opts);
-        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+    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);
         return txSig;
     }
-    async getPlaceAndTakeIx(orderParams, makerInfo) {
+    async getPlaceAndTakeIx(orderParams, makerInfo, referrerInfo) {
+        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({
-            writableMarketIndex: orderParams.marketIndex,
-            writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
+            userAccounts,
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [orderParams.marketIndex],
         });
         let makerOrderId = null;
         if (makerInfo) {
@@ -713,11 +1300,68 @@ class ClearingHouse {
                 isSigner: false,
                 isWritable: true,
             });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
         }
         return await this.program.instruction.placeAndTake(orderParams, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
+    async placeAndMake(orderParams, takerInfo, referrerInfo) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakeIx(orderParams, takerInfo, referrerInfo)), [], this.opts);
+        this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+        return txSig;
+    }
+    async getPlaceAndMakeIx(orderParams, takerInfo, referrerInfo) {
+        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+        const userStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [orderParams.marketIndex],
+        });
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        const takerOrderId = takerInfo.order.orderId;
+        return await this.program.instruction.placeAndMake(orderParams, takerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                taker: takerInfo.taker,
+                takerStats: takerInfo.takerStats,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -728,19 +1372,31 @@ class ClearingHouse {
      * @param marketIndex
      * @returns
      */
-    async closePosition(marketIndex) {
+    async closePosition(marketIndex, limitPrice) {
         const userPosition = this.getUser().getUserPosition(marketIndex);
         if (!userPosition) {
             throw Error(`No position in market ${marketIndex.toString()}`);
         }
-        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, (0, position_1.findDirectionToClose)(userPosition), numericConstants_1.ZERO, userPosition.baseAssetAmount, true, undefined));
+        return await this.placeAndTake({
+            orderType: types_1.OrderType.MARKET,
+            marketIndex,
+            direction: (0, position_1.findDirectionToClose)(userPosition),
+            baseAssetAmount: userPosition.baseAssetAmount.abs(),
+            reduceOnly: true,
+            price: limitPrice,
+        });
     }
     async settlePNLs(users, marketIndex) {
         const ixs = [];
         for (const { settleeUserAccountPublicKey, settleeUserAccount } of users) {
             ixs.push(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex));
         }
-        const tx = new web3_js_1.Transaction().add(...ixs);
+        const tx = new web3_js_1.Transaction()
+            .add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: 1000000,
+            additionalFee: 0,
+        }))
+            .add(...ixs);
         const { txSig } = await this.txSender.send(tx, [], this.opts);
         return txSig;
     }
@@ -749,63 +1405,31 @@ class ClearingHouse {
         return txSig;
     }
     async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
-        const marketAccountMap = new Map();
-        const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        for (const position of settleeUserAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(position.marketIndex);
-                marketAccountMap.set(position.marketIndex.toNumber(), {
-                    pubkey: market.pubkey,
-                    isWritable: true,
-                    isSigner: false,
-                });
-                oracleAccountMap.set(market.amm.oracle.toString(), {
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        for (const userBankBalance of settleeUserAccount.bankBalances) {
-            if (!userBankBalance.balance.eq(numericConstants_1.QUOTE_ASSET_BANK_INDEX)) {
-                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        const marketAccount = this.getMarketAccount(marketIndex.toNumber());
-        marketAccountMap.set(marketIndex.toNumber(), {
-            pubkey: marketAccount.pubkey,
-            isSigner: false,
-            isWritable: true,
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: [marketIndex],
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isSigner: false,
-            isWritable: false,
+        return await this.program.instruction.settlePnl(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: settleeUserAccountPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
         });
-        bankAccountMap.set(numericConstants_1.QUOTE_ASSET_BANK_INDEX.toNumber(), {
-            pubkey: this.getBankAccount(numericConstants_1.QUOTE_ASSET_BANK_INDEX).pubkey,
-            isSigner: false,
-            isWritable: true,
+    }
+    async settleExpiredPosition(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleExpiredPositionIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getSettleExpiredPositionIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: [marketIndex],
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
-        ];
-        return await this.program.instruction.settlePnl(marketIndex, {
+        return await this.program.instruction.settleExpiredPosition(marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
@@ -814,50 +1438,163 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidate(liquidateeUserAccountPublicKey) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);
+    async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)), [], this.opts);
+        this.marketLastSlotCache.set(marketIndex, slot);
         return txSig;
     }
-    async getLiquidateIx(liquidateeUserAccountPublicKey) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const liquidateeUserAccount = (await this.program.account.user.fetch(liquidateeUserAccountPublicKey));
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
+    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [marketIndex],
+        });
+        return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
             },
-        ];
-        const marketAccountInfos = [];
-        const oracleAccountInfos = [];
-        for (const position of liquidateeUserAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(position.marketIndex);
-                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
-                marketAccountInfos.push({
-                    pubkey: marketPublicKey,
-                    isWritable: true,
-                    isSigner: false,
-                });
-                oracleAccountInfos.push({
-                    pubkey: market.amm.oracle,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-        }
-        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
-        const state = this.getStateAccount();
-        const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
-        return await this.program.instruction.liquidate({
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    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 getLiquidateSpotIx(userAccountPublicKey, userAccount, assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [liabilityMarketIndex, assetMarketIndex],
+        });
+        return await this.program.instruction.liquidateSpot(assetMarketIndex, liabilityMarketIndex, maxLiabilityTransfer, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
-                user: liquidateeUserAccountPublicKey,
-                liquidator: userAccountPublicKey,
-                bankVault: quoteAssetBankAccount.vault,
-                bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
-                insuranceVault: state.insuranceVault,
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityMarketIndex, maxLiabilityTransfer)), [], this.opts);
+        this.marketLastSlotCache.set(perpMarketIndex, slot);
+        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 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, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer)), [], this.opts);
+        this.marketLastSlotCache.set(perpMarketIndex, slot);
+        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 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, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
+                liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            writablePerpMarketIndexes: [marketIndex],
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+        });
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        return await this.program.instruction.resolvePerpBankruptcy(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, marketIndex, {
+            accounts: {
+                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(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    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 getResolveSpotBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(), userAccount],
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        const spotMarket = this.getSpotMarketAccount(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,
+                clearingHouseSigner: this.getSignerPublicKey(),
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
             remainingAccounts: remainingAccounts,
@@ -876,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.positions;
-        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,
         });
@@ -906,9 +1641,163 @@ class ClearingHouse {
         this.eventEmitter.emit(eventName, data);
     }
     getOracleDataForMarket(marketIndex) {
-        const oracleKey = this.getMarketAccount(marketIndex).amm.oracle;
+        const oracleKey = this.getPerpMarketAccount(marketIndex).amm.oracle;
+        const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
+    }
+    getOracleDataForSpotMarket(marketIndex) {
+        const oracleKey = this.getSpotMarketAccount(marketIndex).oracle;
         const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
         return oracleData;
     }
+    async initializeInsuranceFundStake(marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getInitializeInsuranceFundStakeIx(marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getInitializeInsuranceFundStakeIx(marketIndex) {
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        return await this.program.instruction.initializeInsuranceFundStake(marketIndex, {
+            accounts: {
+                insuranceFundStake: ifStakeAccountPublicKey,
+                spotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                payer: this.wallet.publicKey,
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async addInsuranceFundStake(marketIndex, amount, collateralAccountPublicKey) {
+        const spotMarket = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        return await this.program.rpc.addInsuranceFundStake(marketIndex, amount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarket.pubkey,
+                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,
+            },
+            remainingAccounts,
+        });
+    }
+    async requestRemoveInsuranceFundStake(marketIndex, amount) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        return await this.program.rpc.requestRemoveInsuranceFundStake(marketIndex, amount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarketAccount.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
+            },
+            remainingAccounts,
+        });
+    }
+    async cancelRequestRemoveInsuranceFundStake(marketIndex) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarketAccount.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
+            },
+            remainingAccounts,
+        });
+    }
+    async removeInsuranceFundStake(marketIndex, collateralAccountPublicKey) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        return await this.program.rpc.removeInsuranceFundStake(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarketAccount.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                userTokenAccount: collateralAccountPublicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async settleRevenueToInsuranceFund(marketIndex) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writableSpotMarketIndexes: [marketIndex],
+        });
+        return await this.program.rpc.settleRevenueToInsuranceFund(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                spotMarket: spotMarketAccount.pubkey,
+                spotMarketVault: spotMarketAccount.vault,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                insuranceFundVault: spotMarketAccount.insuranceFundVault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async resolvePerpPnlDeficit(spotMarketIndex, perpMarketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [perpMarketIndex],
+            writableSpotMarketIndexes: [spotMarketIndex],
+        });
+        const spotMarket = this.getSpotMarketAccount(spotMarketIndex);
+        return await this.program.instruction.resolvePerpPnlDeficit(spotMarketIndex, perpMarketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                spotMarketVault: spotMarket.vault,
+                insuranceFundVault: spotMarket.insuranceFundVault,
+                clearingHouseSigner: this.getSignerPublicKey(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
 }
 exports.ClearingHouse = ClearingHouse;