@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/clearingHouse.js

@@ -0,0 +1,3433 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.ClearingHouse = void 0;
+var anchor_1 = require("@project-serum/anchor");
+var spl_token_1 = require("@solana/spl-token");
+var types_1 = require("./types");
+var anchor = require("@project-serum/anchor");
+var clearing_house_json_1 = require("./idl/clearing_house.json");
+var web3_js_1 = require("@solana/web3.js");
+var pda_1 = require("./addresses/pda");
+var utils_1 = require("./tx/utils");
+var numericConstants_1 = require("./constants/numericConstants");
+var position_1 = require("./math/position");
+var spotBalance_1 = require("./math/spotBalance");
+var userName_1 = require("./userName");
+var pollingClearingHouseAccountSubscriber_1 = require("./accounts/pollingClearingHouseAccountSubscriber");
+var webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketClearingHouseAccountSubscriber");
+var retryTxSender_1 = require("./tx/retryTxSender");
+var clearingHouseUser_1 = require("./clearingHouseUser");
+var config_1 = require("./config");
+var spotMarkets_1 = require("./constants/spotMarkets");
+var clearingHouseUserStats_1 = require("./clearingHouseUserStats");
+var 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.
+ */
+var ClearingHouse = /** @class */ (function () {
+    function ClearingHouse(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.users = new Map();
+        this._isSubscribed = false;
+        this.marketLastSlotCache = new Map();
+        this.connection = config.connection;
+        this.wallet = config.wallet;
+        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);
+        var userIds = (_a = config.userIds) !== null && _a !== void 0 ? _a : [0];
+        this.activeUserId = (_b = config.activeUserId) !== null && _b !== void 0 ? _b : userIds[0];
+        this.userAccountSubscriptionConfig =
+            ((_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.type) === 'polling'
+                ? {
+                    type: 'polling',
+                    accountLoader: config.accountSubscription.accountLoader
+                }
+                : {
+                    type: 'websocket'
+                };
+        this.createUsers(userIds, this.userAccountSubscriptionConfig);
+        if (config.userStats) {
+            this.userStats = new clearingHouseUserStats_1.ClearingHouseUserStats({
+                clearingHouse: this,
+                userStatsAccountPublicKey: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey),
+                accountSubscription: this.userAccountSubscriptionConfig
+            });
+        }
+        var perpMarketIndexes = config.perpMarketIndexes;
+        var spotMarketIndexes = config.spotMarketIndexes;
+        var oracleInfos = config.oracleInfos;
+        if (config.env) {
+            var _l = (0, config_1.getMarketsAndOraclesForSubscription)(config.env), envPerpMarketIndexes = _l.perpMarketIndexes, envSpotMarketIndexes = _l.spotMarketIndexes, envOralceInfos = _l.oracleInfos;
+            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, 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.perpMarketIndexes) !== null && _e !== void 0 ? _e : [], (_f = config.spotMarketIndexes) !== null && _f !== void 0 ? _f : [], (_g = config.oracleInfos) !== null && _g !== void 0 ? _g : []);
+        }
+        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);
+    }
+    Object.defineProperty(ClearingHouse.prototype, "isSubscribed", {
+        get: function () {
+            return this._isSubscribed && this.accountSubscriber.isSubscribed;
+        },
+        set: function (val) {
+            this._isSubscribed = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ClearingHouse.prototype.createUsers = function (userIds, accountSubscriptionConfig) {
+        for (var _i = 0, userIds_1 = userIds; _i < userIds_1.length; _i++) {
+            var userId = userIds_1[_i];
+            var user = this.createUser(userId, accountSubscriptionConfig);
+            this.users.set(userId, user);
+        }
+    };
+    ClearingHouse.prototype.createUser = function (userId, accountSubscriptionConfig) {
+        var userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, userId);
+        return new clearingHouseUser_1.ClearingHouseUser({
+            clearingHouse: this,
+            userAccountPublicKey: userAccountPublicKey,
+            accountSubscription: accountSubscriptionConfig
+        });
+    };
+    ClearingHouse.prototype.subscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var subscribePromises, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        subscribePromises = this.subscribeUsers().concat(this.accountSubscriber.subscribe());
+                        if (this.userStats !== undefined) {
+                            subscribePromises.concat(this.userStats.subscribe());
+                        }
+                        _a = this;
+                        return [4 /*yield*/, Promise.all(subscribePromises)];
+                    case 1:
+                        _a.isSubscribed = (_b.sent()).reduce(function (success, prevSuccess) { return success && prevSuccess; });
+                        return [2 /*return*/, this.isSubscribed];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.subscribeUsers = function () {
+        return __spreadArray([], this.users.values(), true).map(function (user) { return user.subscribe(); });
+    };
+    /**
+     *	Forces the accountSubscriber to fetch account updates from rpc
+     */
+    ClearingHouse.prototype.fetchAccounts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var promises;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        promises = __spreadArray([], this.users.values(), true).map(function (user) { return user.fetchAccounts(); })
+                            .concat(this.accountSubscriber.fetch());
+                        if (this.userStats) {
+                            promises.concat(this.userStats.fetchAccounts());
+                        }
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.unsubscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var unsubscribePromises;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
+                        if (this.userStats !== undefined) {
+                            unsubscribePromises.concat(this.userStats.unsubscribe());
+                        }
+                        return [4 /*yield*/, Promise.all(unsubscribePromises)];
+                    case 1:
+                        _a.sent();
+                        this.isSubscribed = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.unsubscribeUsers = function () {
+        return __spreadArray([], this.users.values(), true).map(function (user) { return user.unsubscribe(); });
+    };
+    ClearingHouse.prototype.getStatePublicKey = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.statePublicKey) {
+                            return [2 /*return*/, this.statePublicKey];
+                        }
+                        _a = this;
+                        return [4 /*yield*/, (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId)];
+                    case 1:
+                        _a.statePublicKey = _b.sent();
+                        return [2 /*return*/, this.statePublicKey];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getSignerPublicKey = function () {
+        if (this.signerPublicKey) {
+            return this.signerPublicKey;
+        }
+        this.signerPublicKey = (0, pda_1.getClearingHouseSignerPublicKey)(this.program.programId);
+        return this.signerPublicKey;
+    };
+    ClearingHouse.prototype.getStateAccount = function () {
+        return this.accountSubscriber.getStateAccountAndSlot().data;
+    };
+    ClearingHouse.prototype.getPerpMarketAccount = function (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;
+    };
+    ClearingHouse.prototype.getPerpMarketAccounts = function () {
+        return this.accountSubscriber
+            .getMarketAccountsAndSlots()
+            .map(function (value) { return value.data; });
+    };
+    ClearingHouse.prototype.getSpotMarketAccount = function (marketIndex) {
+        marketIndex = marketIndex instanceof anchor_1.BN ? marketIndex : new anchor_1.BN(marketIndex);
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
+    };
+    ClearingHouse.prototype.getQuoteSpotMarketAccount = function () {
+        return this.accountSubscriber.getSpotMarketAccountAndSlot(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).data;
+    };
+    ClearingHouse.prototype.getOraclePriceDataAndSlot = function (oraclePublicKey) {
+        return this.accountSubscriber.getOraclePriceDataAndSlot(oraclePublicKey);
+    };
+    ClearingHouse.prototype.getSerumV3FulfillmentConfig = function (serumMarket) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket)];
+                    case 1:
+                        address = _a.sent();
+                        return [4 /*yield*/, this.program.account.serumV3FulfillmentConfig.fetch(address)];
+                    case 2: return [2 /*return*/, (_a.sent())];
+                }
+            });
+        });
+    };
+    /**
+     * Update the wallet to use for clearing house transactions and linked user account
+     * @param newWallet
+     * @param userIds
+     * @param activeUserId
+     */
+    ClearingHouse.prototype.updateWallet = function (newWallet, userIds, activeUserId) {
+        if (userIds === void 0) { userIds = [0]; }
+        if (activeUserId === void 0) { activeUserId = 0; }
+        return __awaiter(this, void 0, void 0, function () {
+            var newProvider, newProgram;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        newProvider = new anchor_1.AnchorProvider(this.connection, newWallet, this.opts);
+                        newProgram = new anchor_1.Program(clearing_house_json_1["default"], this.program.programId, newProvider);
+                        // Update provider for txSender with new wallet details
+                        this.txSender.provider = newProvider;
+                        this.wallet = newWallet;
+                        this.provider = newProvider;
+                        this.program = newProgram;
+                        if (!this.isSubscribed) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.all(this.unsubscribeUsers())];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.users.clear();
+                        this.createUsers(userIds, this.userAccountSubscriptionConfig);
+                        if (!this.isSubscribed) return [3 /*break*/, 4];
+                        return [4 /*yield*/, Promise.all(this.subscribeUsers())];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        this.activeUserId = activeUserId;
+                        this.userStatsAccountPublicKey = undefined;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.switchActiveUser = function (userId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.activeUserId = userId;
+                return [2 /*return*/];
+            });
+        });
+    };
+    ClearingHouse.prototype.addUser = function (userId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.users.has(userId)) {
+                            return [2 /*return*/];
+                        }
+                        user = this.createUser(userId, this.userAccountSubscriptionConfig);
+                        return [4 /*yield*/, user.subscribe()];
+                    case 1:
+                        _a.sent();
+                        this.users.set(userId, user);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.initializeUserAccount = function (userId, name, referrerInfo) {
+        if (userId === void 0) { userId = 0; }
+        if (name === void 0) { name = userName_1.DEFAULT_USER_NAME; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, userAccountPublicKey, initializeUserAccountIx, tx, _b, _c, txSig;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.getInitializeUserInstructions(userId, name, referrerInfo)];
+                    case 1:
+                        _a = _d.sent(), userAccountPublicKey = _a[0], initializeUserAccountIx = _a[1];
+                        tx = new web3_js_1.Transaction();
+                        if (!(userId === 0)) return [3 /*break*/, 3];
+                        // not the safest assumption, can explicitly check if user stats account exists if it causes problems
+                        _c = (_b = tx).add;
+                        return [4 /*yield*/, this.getInitializeUserStatsIx()];
+                    case 2:
+                        // not the safest assumption, can explicitly check if user stats account exists if it causes problems
+                        _c.apply(_b, [_d.sent()]);
+                        _d.label = 3;
+                    case 3:
+                        tx.add(initializeUserAccountIx);
+                        return [4 /*yield*/, this.txSender.send(tx, [], this.opts)];
+                    case 4:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, [txSig, userAccountPublicKey]];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getInitializeUserInstructions = function (userId, name, referrerInfo) {
+        if (userId === void 0) { userId = 0; }
+        if (name === void 0) { name = userName_1.DEFAULT_USER_NAME; }
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, nameBuffer, initializeUserAccountIx, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId)];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = new Array();
+                        if (referrerInfo !== undefined) {
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrer,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrerStats,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        nameBuffer = (0, userName_1.encodeName)(name);
+                        _b = (_a = this.program.instruction).initializeUser;
+                        _c = [userId, nameBuffer];
+                        _d = {};
+                        _e = {
+                            user: userAccountPublicKey,
+                            userStats: this.getUserStatsAccountPublicKey(),
+                            authority: this.wallet.publicKey,
+                            payer: this.wallet.publicKey,
+                            rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                            systemProgram: anchor.web3.SystemProgram.programId
+                        };
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3:
+                        initializeUserAccountIx = _f.sent();
+                        return [2 /*return*/, [userAccountPublicKey, initializeUserAccountIx]];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getInitializeUserStatsIx = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _b = (_a = this.program.instruction).initializeUserStats;
+                        _c = {};
+                        _d = {
+                            userStats: this.getUserStatsAccountPublicKey(),
+                            authority: this.wallet.publicKey,
+                            payer: this.wallet.publicKey,
+                            rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                            systemProgram: anchor.web3.SystemProgram.programId
+                        };
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [(_c.accounts = (_d.state = _e.sent(),
+                                _d),
+                                _c)])];
+                    case 2: return [2 /*return*/, _e.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getUser = function (userId) {
+        userId = userId !== null && userId !== void 0 ? userId : this.activeUserId;
+        if (!this.users.has(userId)) {
+            throw new Error("Clearing House has no user for user id ".concat(userId));
+        }
+        return this.users.get(userId);
+    };
+    ClearingHouse.prototype.getUsers = function () {
+        return __spreadArray([], this.users.values(), true);
+    };
+    ClearingHouse.prototype.getUserStats = function () {
+        return this.userStats;
+    };
+    ClearingHouse.prototype.getUserStatsAccountPublicKey = function () {
+        if (this.userStatsAccountPublicKey) {
+            return this.userStatsAccountPublicKey;
+        }
+        this.userStatsAccountPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey);
+        return this.userStatsAccountPublicKey;
+    };
+    ClearingHouse.prototype.getUserAccountPublicKey = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getUser().userAccountPublicKey];
+            });
+        });
+    };
+    ClearingHouse.prototype.getUserAccount = function (userId) {
+        return this.getUser(userId).getUserAccount();
+    };
+    ClearingHouse.prototype.getUserAccountAndSlot = function (userId) {
+        return this.getUser(userId).getUserAccountAndSlot();
+    };
+    ClearingHouse.prototype.getSpotPosition = function (marketIndex) {
+        var marketIndexBN = marketIndex instanceof anchor_1.BN ? marketIndex : new anchor_1.BN(marketIndex);
+        return this.getUserAccount().spotPositions.find(function (spotPosition) {
+            return spotPosition.marketIndex.eq(marketIndexBN);
+        });
+    };
+    ClearingHouse.prototype.getQuoteAssetTokenAmount = function () {
+        var spotMarket = this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        var spotPosition = this.getSpotPosition(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+        return (0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarket, spotPosition.balanceType);
+    };
+    ClearingHouse.prototype.getRemainingAccounts = function (params) {
+        var userAccountAndSlot = this.getUserAccountAndSlot();
+        if (!userAccountAndSlot) {
+            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
+        }
+        var userAccount = userAccountAndSlot.data, lastUserPositionsSlot = userAccountAndSlot.slot;
+        var oracleAccountMap = new Map();
+        var spotMarketAccountMap = new Map();
+        var perpMarketAccountMap = new Map();
+        for (var _i = 0, _a = this.marketLastSlotCache.entries(); _i < _a.length; _i++) {
+            var _b = _a[_i], marketIndexNum = _b[0], slot = _b[1];
+            // if cache has more recent slot than user positions account slot, add market to remaining accounts
+            // otherwise remove from slot
+            if (slot > lastUserPositionsSlot) {
+                var marketAccount = this.getPerpMarketAccount(marketIndexNum);
+                perpMarketAccountMap.set(marketIndexNum, {
+                    pubkey: marketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false
+                });
+                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                    pubkey: marketAccount.amm.oracle,
+                    isSigner: false,
+                    isWritable: false
+                });
+            }
+            else {
+                this.marketLastSlotCache["delete"](marketIndexNum);
+            }
+        }
+        for (var _c = 0, _d = userAccount.perpPositions; _c < _d.length; _c++) {
+            var position = _d[_c];
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                var marketIndexNum = position.marketIndex.toNumber();
+                var marketAccount = this.getPerpMarketAccount(marketIndexNum);
+                perpMarketAccountMap.set(marketIndexNum, {
+                    pubkey: marketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false
+                });
+                oracleAccountMap.set(marketAccount.pubkey.toString(), {
+                    pubkey: marketAccount.amm.oracle,
+                    isSigner: false,
+                    isWritable: false
+                });
+            }
+        }
+        if (params.readablePerpMarketIndex) {
+            var marketAccount = this.getPerpMarketAccount(params.readablePerpMarketIndex.toNumber());
+            perpMarketAccountMap.set(params.readablePerpMarketIndex.toNumber(), {
+                pubkey: marketAccount.pubkey,
+                isSigner: false,
+                isWritable: true
+            });
+            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                pubkey: marketAccount.amm.oracle,
+                isSigner: false,
+                isWritable: false
+            });
+        }
+        if (params.writablePerpMarketIndex) {
+            var marketAccount = this.getPerpMarketAccount(params.writablePerpMarketIndex.toNumber());
+            perpMarketAccountMap.set(params.writablePerpMarketIndex.toNumber(), {
+                pubkey: marketAccount.pubkey,
+                isSigner: false,
+                isWritable: true
+            });
+            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                pubkey: marketAccount.amm.oracle,
+                isSigner: false,
+                isWritable: false
+            });
+        }
+        for (var _e = 0, _f = userAccount.spotPositions; _e < _f.length; _e++) {
+            var spotPosition = _f[_e];
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                var spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false
+                });
+                if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
+                        isSigner: false,
+                        isWritable: false
+                    });
+                }
+            }
+        }
+        if (params.readableSpotMarketIndex) {
+            var spotMarketAccount = this.getSpotMarketAccount(params.readableSpotMarketIndex);
+            spotMarketAccountMap.set(params.readableSpotMarketIndex.toNumber(), {
+                pubkey: spotMarketAccount.pubkey,
+                isSigner: false,
+                isWritable: false
+            });
+            if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                    pubkey: spotMarketAccount.oracle,
+                    isSigner: false,
+                    isWritable: false
+                });
+            }
+        }
+        if (params.writableSpotMarketIndex) {
+            var spotMarketAccount = this.getSpotMarketAccount(params.writableSpotMarketIndex);
+            spotMarketAccountMap.set(params.writableSpotMarketIndex.toNumber(), {
+                pubkey: spotMarketAccount.pubkey,
+                isSigner: false,
+                isWritable: true
+            });
+            if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                    pubkey: spotMarketAccount.oracle,
+                    isSigner: false,
+                    isWritable: false
+                });
+            }
+        }
+        return __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), perpMarketAccountMap.values(), true);
+    };
+    ClearingHouse.prototype.getOrder = function (orderId) {
+        var _a;
+        var 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(function (order) {
+            return order.orderId.eq(orderIdBN);
+        });
+    };
+    ClearingHouse.prototype.getOrderByUserId = function (userOrderId) {
+        var _a;
+        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find(function (order) { return order.userOrderId === userOrderId; });
+    };
+    ClearingHouse.prototype.deposit = function (amount, marketIndex, collateralAccountPublicKey, userId, reduceOnly) {
+        if (reduceOnly === void 0) { reduceOnly = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tx, additionalSigners, spotMarketAccount, isSolMarket, authority, createWSOLTokenAccount, _a, ixs, signers, pubkey, depositCollateralIx, txSig;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        tx = new web3_js_1.Transaction();
+                        additionalSigners = [];
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
+                        authority = this.wallet.publicKey;
+                        createWSOLTokenAccount = isSolMarket && collateralAccountPublicKey.equals(authority);
+                        if (!createWSOLTokenAccount) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getWrappedSolAccountCreationIxs(amount)];
+                    case 1:
+                        _a = _b.sent(), ixs = _a.ixs, signers = _a.signers, pubkey = _a.pubkey;
+                        collateralAccountPublicKey = pubkey;
+                        ixs.forEach(function (ix) {
+                            tx.add(ix);
+                        });
+                        signers.forEach(function (signer) { return additionalSigners.push(signer); });
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, this.getDepositInstruction(amount, marketIndex, collateralAccountPublicKey, userId, reduceOnly, true)];
+                    case 3:
+                        depositCollateralIx = _b.sent();
+                        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, []));
+                        }
+                        return [4 /*yield*/, this.txSender.send(tx, additionalSigners, this.opts)];
+                    case 4:
+                        txSig = (_b.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getDepositInstruction = function (amount, marketIndex, userTokenAccount, userId, reduceOnly, userInitialized) {
+        if (reduceOnly === void 0) { reduceOnly = false; }
+        if (userInitialized === void 0) { userInitialized = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, _a, remainingAccounts, spotMarketAccount_1, spotMarketAccount, _b, _c, _d;
+            var _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        if (!userId) return [3 /*break*/, 2];
+                        return [4 /*yield*/, (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId)];
+                    case 1:
+                        _a = _g.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 3:
+                        _a = _g.sent();
+                        _g.label = 4;
+                    case 4:
+                        userAccountPublicKey = _a;
+                        remainingAccounts = [];
+                        if (userInitialized) {
+                            remainingAccounts = this.getRemainingAccounts({
+                                writableSpotMarketIndex: marketIndex
+                            });
+                        }
+                        else {
+                            spotMarketAccount_1 = this.getSpotMarketAccount(marketIndex);
+                            if (!spotMarketAccount_1.oracle.equals(web3_js_1.PublicKey["default"])) {
+                                remainingAccounts.push({
+                                    pubkey: spotMarketAccount_1.oracle,
+                                    isSigner: false,
+                                    isWritable: false
+                                });
+                            }
+                            remainingAccounts.push({
+                                pubkey: spotMarketAccount_1.pubkey,
+                                isSigner: false,
+                                isWritable: true
+                            });
+                        }
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        _c = (_b = this.program.instruction).deposit;
+                        _d = [marketIndex,
+                            amount,
+                            reduceOnly];
+                        _e = {};
+                        _f = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 5: return [4 /*yield*/, _c.apply(_b, _d.concat([(_e.accounts = (_f.state = _g.sent(),
+                                _f.spotMarket = spotMarketAccount.pubkey,
+                                _f.spotMarketVault = spotMarketAccount.vault,
+                                _f.user = userAccountPublicKey,
+                                _f.userStats = this.getUserStatsAccountPublicKey(),
+                                _f.userTokenAccount = userTokenAccount,
+                                _f.authority = this.wallet.publicKey,
+                                _f.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _f),
+                                _e.remainingAccounts = remainingAccounts,
+                                _e)]))];
+                    case 6: return [2 /*return*/, _g.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.checkIfAccountExists = function (account) {
+        return __awaiter(this, void 0, void 0, function () {
+            var accountInfo, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.connection.getAccountInfo(account)];
+                    case 1:
+                        accountInfo = _a.sent();
+                        return [2 /*return*/, accountInfo && true];
+                    case 2:
+                        e_1 = _a.sent();
+                        // Doesn't already exist
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getSolWithdrawalIxs = function (marketIndex, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, authority, _a, ixs, signers, pubkey, withdrawIx;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        result = {
+                            ixs: [],
+                            signers: [],
+                            pubkey: web3_js_1.PublicKey["default"]
+                        };
+                        authority = this.wallet.publicKey;
+                        return [4 /*yield*/, this.getWrappedSolAccountCreationIxs(amount)];
+                    case 1:
+                        _a = _b.sent(), ixs = _a.ixs, signers = _a.signers, pubkey = _a.pubkey;
+                        result.pubkey = pubkey;
+                        ixs.forEach(function (ix) {
+                            result.ixs.push(ix);
+                        });
+                        signers.forEach(function (ix) {
+                            result.signers.push(ix);
+                        });
+                        return [4 /*yield*/, this.getWithdrawIx(amount, marketIndex, pubkey, true)];
+                    case 2:
+                        withdrawIx = _b.sent();
+                        result.ixs.push(withdrawIx);
+                        result.ixs.push(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, pubkey, authority, authority, []));
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getWrappedSolAccountCreationIxs = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var wrappedSolAccount, result, rentSpaceLamports, depositAmountLamports, authority;
+            return __generator(this, function (_a) {
+                wrappedSolAccount = new web3_js_1.Keypair();
+                result = {
+                    ixs: [],
+                    signers: [],
+                    pubkey: wrappedSolAccount.publicKey
+                };
+                rentSpaceLamports = new anchor_1.BN(web3_js_1.LAMPORTS_PER_SOL / 100);
+                depositAmountLamports = amount.add(rentSpaceLamports);
+                authority = this.wallet.publicKey;
+                result.ixs.push(web3_js_1.SystemProgram.createAccount({
+                    fromPubkey: authority,
+                    newAccountPubkey: wrappedSolAccount.publicKey,
+                    lamports: depositAmountLamports.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 [2 /*return*/, result];
+            });
+        });
+    };
+    /**
+     * Creates the Clearing House User account for a user, and deposits some initial collateral
+     * @param amount
+     * @param userTokenAccount
+     * @param marketIndex
+     * @param userId
+     * @param name
+     * @param fromUserId
+     * @returns
+     */
+    ClearingHouse.prototype.initializeUserAccountAndDepositCollateral = function (amount, userTokenAccount, marketIndex, userId, name, fromUserId, referrerInfo) {
+        if (marketIndex === void 0) { marketIndex = new anchor_1.BN(0); }
+        if (userId === void 0) { userId = 0; }
+        if (name === void 0) { name = userName_1.DEFAULT_USER_NAME; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, userAccountPublicKey, initializeUserAccountIx, additionalSigners, spotMarket, isSolMarket, tx, authority, createWSOLTokenAccount, _b, startIxs, signers, pubkey, depositCollateralIx, _c, _d, _e, txSig;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getInitializeUserInstructions(userId, name, referrerInfo)];
+                    case 1:
+                        _a = _f.sent(), userAccountPublicKey = _a[0], initializeUserAccountIx = _a[1];
+                        additionalSigners = [];
+                        spotMarket = this.getSpotMarketAccount(marketIndex);
+                        isSolMarket = spotMarket.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
+                        tx = new web3_js_1.Transaction();
+                        authority = this.wallet.publicKey;
+                        createWSOLTokenAccount = isSolMarket && userTokenAccount.equals(authority);
+                        if (!createWSOLTokenAccount) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.getWrappedSolAccountCreationIxs(amount)];
+                    case 2:
+                        _b = _f.sent(), startIxs = _b.ixs, signers = _b.signers, pubkey = _b.pubkey;
+                        userTokenAccount = pubkey;
+                        startIxs.forEach(function (ix) {
+                            tx.add(ix);
+                        });
+                        signers.forEach(function (signer) { return additionalSigners.push(signer); });
+                        _f.label = 3;
+                    case 3:
+                        if (!(fromUserId != null)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.getTransferDepositIx(amount, marketIndex, fromUserId, userId)];
+                    case 4:
+                        _c = _f.sent();
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, this.getDepositInstruction(amount, marketIndex, userTokenAccount, userId, false, false)];
+                    case 6:
+                        _c = _f.sent();
+                        _f.label = 7;
+                    case 7:
+                        depositCollateralIx = _c;
+                        if (!(userId === 0)) return [3 /*break*/, 9];
+                        _e = (_d = tx).add;
+                        return [4 /*yield*/, this.getInitializeUserStatsIx()];
+                    case 8:
+                        _e.apply(_d, [_f.sent()]);
+                        _f.label = 9;
+                    case 9:
+                        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, []));
+                        }
+                        return [4 /*yield*/, this.txSender.send(tx, additionalSigners, this.opts)];
+                    case 10:
+                        txSig = (_f.sent()).txSig;
+                        return [2 /*return*/, [txSig, userAccountPublicKey]];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.initializeUserAccountForDevnet = function (userId, name, marketIndex, tokenFaucet, amount, referrerInfo) {
+        if (userId === void 0) { userId = 0; }
+        if (name === void 0) { name = userName_1.DEFAULT_USER_NAME; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, associateTokenPublicKey, createAssociatedAccountIx, mintToIx, _b, userAccountPublicKey, initializeUserAccountIx, depositCollateralIx, tx, _c, _d, txSig;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount)];
+                    case 1:
+                        _a = _e.sent(), associateTokenPublicKey = _a[0], createAssociatedAccountIx = _a[1], mintToIx = _a[2];
+                        return [4 /*yield*/, this.getInitializeUserInstructions(userId, name, referrerInfo)];
+                    case 2:
+                        _b = _e.sent(), userAccountPublicKey = _b[0], initializeUserAccountIx = _b[1];
+                        return [4 /*yield*/, this.getDepositInstruction(amount, marketIndex, associateTokenPublicKey, userId, false, false)];
+                    case 3:
+                        depositCollateralIx = _e.sent();
+                        tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToIx);
+                        if (!(userId === 0)) return [3 /*break*/, 5];
+                        _d = (_c = tx).add;
+                        return [4 /*yield*/, this.getInitializeUserStatsIx()];
+                    case 4:
+                        _d.apply(_c, [_e.sent()]);
+                        _e.label = 5;
+                    case 5:
+                        tx.add(initializeUserAccountIx).add(depositCollateralIx);
+                        return [4 /*yield*/, this.program.provider.sendAndConfirm(tx, [])];
+                    case 6:
+                        txSig = _e.sent();
+                        return [2 /*return*/, [txSig, userAccountPublicKey]];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.withdraw = function (amount, marketIndex, userTokenAccount, reduceOnly) {
+        if (reduceOnly === void 0) { reduceOnly = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tx, additionalSigners, spotMarketAccount, isSolMarket, authority, createWSOLTokenAccount, _a, ixs, signers, pubkey, withdrawCollateral, txSig;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        tx = new web3_js_1.Transaction();
+                        additionalSigners = [];
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
+                        authority = this.wallet.publicKey;
+                        createWSOLTokenAccount = isSolMarket && userTokenAccount.equals(authority);
+                        if (!createWSOLTokenAccount) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getWrappedSolAccountCreationIxs(amount)];
+                    case 1:
+                        _a = _b.sent(), ixs = _a.ixs, signers = _a.signers, pubkey = _a.pubkey;
+                        userTokenAccount = pubkey;
+                        ixs.forEach(function (ix) {
+                            tx.add(ix);
+                        });
+                        signers.forEach(function (signer) { return additionalSigners.push(signer); });
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, this.getWithdrawIx(amount, spotMarketAccount.marketIndex, userTokenAccount, reduceOnly)];
+                    case 3:
+                        withdrawCollateral = _b.sent();
+                        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, []));
+                        }
+                        return [4 /*yield*/, this.txSender.send(tx, additionalSigners, this.opts)];
+                    case 4:
+                        txSig = (_b.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getWithdrawIx = function (amount, marketIndex, userTokenAccount, reduceOnly) {
+        if (reduceOnly === void 0) { reduceOnly = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, spotMarketAccount, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        _b = (_a = this.program.instruction).withdraw;
+                        _c = [marketIndex,
+                            amount,
+                            reduceOnly];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.spotMarket = spotMarketAccount.pubkey,
+                                _e.spotMarketVault = spotMarketAccount.vault,
+                                _e.clearingHouseSigner = this.getSignerPublicKey(),
+                                _e.user = userAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.userTokenAccount = userTokenAccount,
+                                _e.authority = this.wallet.publicKey,
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.transferDeposit = function (amount, marketIndex, fromUserId, toUserId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getTransferDepositIx(amount, marketIndex, fromUserId, toUserId)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getTransferDepositIx = function (amount, marketIndex, fromUserId, toUserId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fromUser, toUser, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, fromUserId)];
+                    case 1:
+                        fromUser = _f.sent();
+                        return [4 /*yield*/, (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, toUserId)];
+                    case 2:
+                        toUser = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.instruction).transferDeposit;
+                        _c = [marketIndex, amount];
+                        _d = {};
+                        _e = {
+                            authority: this.wallet.publicKey,
+                            fromUser: fromUser,
+                            toUser: toUser,
+                            userStats: this.getUserStatsAccountPublicKey()
+                        };
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 3: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 4: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.updateSpotMarketCumulativeInterest = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.updateSpotMarketCumulativeInterestIx(marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.updateSpotMarketCumulativeInterestIx = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spotMarket;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spotMarket = this.getSpotMarketAccount(marketIndex);
+                        return [4 /*yield*/, this.program.instruction.updateSpotMarketCumulativeInterest({
+                                accounts: {
+                                    spotMarket: spotMarket.pubkey
+                                }
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settleLP = function (settleeUserAccountPublicKey, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.settleLPIx(settleeUserAccountPublicKey, marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settleLPIx = function (settleeUserAccountPublicKey, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var settleeUserAccount, userPositions, remainingAccounts, foundMarket, _i, userPositions_1, position, marketPublicKey, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.program.account.user.fetch(settleeUserAccountPublicKey)];
+                    case 1:
+                        settleeUserAccount = (_f.sent());
+                        userPositions = settleeUserAccount.perpPositions;
+                        remainingAccounts = [];
+                        foundMarket = false;
+                        _i = 0, userPositions_1 = userPositions;
+                        _f.label = 2;
+                    case 2:
+                        if (!(_i < userPositions_1.length)) return [3 /*break*/, 5];
+                        position = userPositions_1[_i];
+                        if (!!(0, position_1.positionIsAvailable)(position)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex)];
+                    case 3:
+                        marketPublicKey = _f.sent();
+                        remainingAccounts.push({
+                            pubkey: marketPublicKey,
+                            isWritable: true,
+                            isSigner: false
+                        });
+                        if (marketIndex.eq(position.marketIndex)) {
+                            foundMarket = true;
+                        }
+                        _f.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        if (!foundMarket) {
+                            console.log('Warning: lp is not in the market specified -- tx will likely fail');
+                        }
+                        _b = (_a = this.program.instruction).settleLp;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 6: return [2 /*return*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = settleeUserAccountPublicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.removeLiquidity = function (marketIndex, sharesToBurn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getRemoveLiquidityIx(marketIndex, sharesToBurn)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getRemoveLiquidityIx = function (marketIndex, sharesToBurn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, userAccount, perpPosition, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            writablePerpMarketIndex: marketIndex
+                        });
+                        if (sharesToBurn == undefined) {
+                            userAccount = this.getUserAccount();
+                            perpPosition = userAccount.perpPositions.filter(function (position) {
+                                return position.marketIndex.eq(marketIndex);
+                            })[0];
+                            sharesToBurn = perpPosition.lpShares;
+                            console.log('burning lp shares:', sharesToBurn.toString());
+                        }
+                        _b = (_a = this.program.instruction).removeLiquidity;
+                        _c = [sharesToBurn, marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [2 /*return*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.addLiquidity = function (amount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getAddLiquidityIx(amount, marketIndex)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getAddLiquidityIx = function (amount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            writablePerpMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.instruction).addLiquidity;
+                        _c = [amount, marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [2 /*return*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.openPosition = function (direction, amount, marketIndex, limitPrice) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.placeAndTake({
+                            orderType: types_1.OrderType.MARKET,
+                            marketIndex: marketIndex,
+                            direction: direction,
+                            baseAssetAmount: amount,
+                            price: limitPrice
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.sendSignedTx = function (tx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.txSender.send(tx, undefined, this.opts, true)];
+                    case 1:
+                        txSig = (_a.sent()).txSig;
+                        return [2 /*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
+     */
+    ClearingHouse.prototype.sendMarketOrderAndGetSignedFillTx = function (orderParams, userAccountPublicKey, userAccount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var marketIndex, orderId, marketOrderTx, _a, fillTx, _b, currentBlockHash, _c, signedMarketOrderTx, signedFillTx, _d, txSig, slot;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        marketIndex = orderParams.marketIndex;
+                        orderId = userAccount.nextOrderId;
+                        _a = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getPlaceOrderIx(orderParams)];
+                    case 1:
+                        marketOrderTx = _a.apply(void 0, [_e.sent()]);
+                        _b = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getFillOrderIx(userAccountPublicKey, userAccount, {
+                                orderId: orderId,
+                                marketIndex: marketIndex
+                            })];
+                    case 2:
+                        fillTx = _b.apply(void 0, [_e.sent()]);
+                        return [4 /*yield*/, this.connection.getLatestBlockhash('finalized')];
+                    case 3:
+                        currentBlockHash = (_e.sent()).blockhash;
+                        marketOrderTx.recentBlockhash = currentBlockHash;
+                        fillTx.recentBlockhash = currentBlockHash;
+                        marketOrderTx.feePayer = userAccount.authority;
+                        fillTx.feePayer = userAccount.authority;
+                        return [4 /*yield*/, this.provider.wallet.signAllTransactions([marketOrderTx, fillTx])];
+                    case 4:
+                        _c = _e.sent(), signedMarketOrderTx = _c[0], signedFillTx = _c[1];
+                        return [4 /*yield*/, this.txSender.send(signedMarketOrderTx, [], this.opts, true)];
+                    case 5:
+                        _d = _e.sent(), txSig = _d.txSig, slot = _d.slot;
+                        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+                        return [2 /*return*/, { txSig: txSig, signedFillTx: signedFillTx }];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.placeOrder = function (orderParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getPlaceOrderIx(orderParams)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getOrderParams = function (optionalOrderParams, marketType) {
+        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams, {
+            marketType: marketType
+        });
+    };
+    ClearingHouse.prototype.getPlaceOrderIx = function (orderParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            readablePerpMarketIndex: orderParams.marketIndex
+                        });
+                        _b = (_a = this.program.instruction).placeOrder;
+                        _c = [orderParams];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.updateAMMs = function (marketIndexes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getUpdateAMMsIx(marketIndexes)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getUpdateAMMsIx = function (marketIndexes) {
+        return __awaiter(this, void 0, void 0, function () {
+            var i, marketAccountInfos, oracleAccountInfos, _i, marketIndexes_1, marketIndex, market, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        for (i = marketIndexes.length; i < 5; i++) {
+                            marketIndexes.push(new anchor_1.BN(100));
+                        }
+                        marketAccountInfos = [];
+                        oracleAccountInfos = [];
+                        for (_i = 0, marketIndexes_1 = marketIndexes; _i < marketIndexes_1.length; _i++) {
+                            marketIndex = marketIndexes_1[_i];
+                            if (!marketIndex.eq(new anchor_1.BN(100))) {
+                                market = this.getPerpMarketAccount(marketIndex);
+                                marketAccountInfos.push({
+                                    pubkey: market.pubkey,
+                                    isWritable: true,
+                                    isSigner: false
+                                });
+                                oracleAccountInfos.push({
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        remainingAccounts = oracleAccountInfos.concat(marketAccountInfos);
+                        _b = (_a = this.program.instruction).updateAmms;
+                        _c = [marketIndexes];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settleExpiredMarket = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getSettleExpiredMarketIx(marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getSettleExpiredMarketIx = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var marketAccountInfos, oracleAccountInfos, spotMarketAccountInfos, market, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        marketAccountInfos = [];
+                        oracleAccountInfos = [];
+                        spotMarketAccountInfos = [];
+                        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
+                        });
+                        remainingAccounts = oracleAccountInfos
+                            .concat(spotMarketAccountInfos)
+                            .concat(marketAccountInfos);
+                        _b = (_a = this.program.instruction).settleExpiredMarket;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.cancelOrder = function (orderId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getCancelOrderIx(orderId)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getCancelOrderIx = function (orderId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({});
+                        _b = (_a = this.program.instruction).cancelOrder;
+                        _c = [orderId !== null && orderId !== void 0 ? orderId : null];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.cancelOrderByUserId = function (userOrderId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getCancelOrderByUserIdIx(userOrderId)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getCancelOrderByUserIdIx = function (userOrderId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, order, oracle, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        order = this.getOrderByUserId(userOrderId);
+                        oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
+                        remainingAccounts = this.getRemainingAccounts({});
+                        _b = (_a = this.program.instruction).cancelOrderByUserId;
+                        _c = [userOrderId];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.authority = this.wallet.publicKey,
+                                _e.oracle = oracle,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.fillOrder = function (userAccountPublicKey, user, order, makerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getFillOrderIx = function (userAccountPublicKey, userAccount, order, makerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userStatsPublicKey, fillerPublicKey, fillerStatsPublicKey, marketIndex, marketAccount, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap, _i, _a, spotPosition, spotMarketAccount, _b, _c, position, market, remainingAccounts, orderId, makerOrderId, _d, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        fillerPublicKey = _j.sent();
+                        fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
+                        marketIndex = order
+                            ? order.marketIndex
+                            : userAccount.orders.find(function (order) {
+                                return order.orderId.eq(userAccount.nextOrderId.sub(numericConstants_1.ONE));
+                            }).marketIndex;
+                        marketAccount = this.getPerpMarketAccount(marketIndex);
+                        oracleAccountMap = new Map();
+                        spotMarketAccountMap = new Map();
+                        perpMarketAccountMap = new Map();
+                        for (_i = 0, _a = userAccount.spotPositions; _i < _a.length; _i++) {
+                            spotPosition = _a[_i];
+                            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                                spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                                    pubkey: spotMarketAccount.pubkey,
+                                    isSigner: false,
+                                    isWritable: false
+                                });
+                                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey["default"])) {
+                                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                                        pubkey: spotMarketAccount.oracle,
+                                        isSigner: false,
+                                        isWritable: false
+                                    });
+                                }
+                            }
+                        }
+                        for (_b = 0, _c = userAccount.perpPositions; _b < _c.length; _b++) {
+                            position = _c[_b];
+                            if (!(0, position_1.positionIsAvailable)(position) &&
+                                !position.marketIndex.eq(order.marketIndex)) {
+                                market = this.getPerpMarketAccount(position.marketIndex);
+                                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                                    pubkey: market.pubkey,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                                oracleAccountMap.set(market.amm.oracle.toString(), {
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        perpMarketAccountMap.set(marketIndex.toNumber(), {
+                            pubkey: marketAccount.pubkey,
+                            isWritable: true,
+                            isSigner: false
+                        });
+                        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                            pubkey: marketAccount.amm.oracle,
+                            isWritable: false,
+                            isSigner: false
+                        });
+                        remainingAccounts = __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), perpMarketAccountMap.values(), true);
+                        if (makerInfo) {
+                            remainingAccounts.push({
+                                pubkey: makerInfo.maker,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: makerInfo.makerStats,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        if (referrerInfo) {
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrer,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrerStats,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        orderId = order.orderId;
+                        makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+                        _e = (_d = this.program.instruction).fillOrder;
+                        _f = [orderId, makerOrderId];
+                        _g = {};
+                        _h = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _e.apply(_d, _f.concat([(_g.accounts = (_h.state = _j.sent(),
+                                _h.filler = fillerPublicKey,
+                                _h.fillerStats = fillerStatsPublicKey,
+                                _h.user = userAccountPublicKey,
+                                _h.userStats = userStatsPublicKey,
+                                _h.authority = this.wallet.publicKey,
+                                _h),
+                                _g.remainingAccounts = remainingAccounts,
+                                _g)]))];
+                    case 3: return [2 /*return*/, _j.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.placeSpotOrder = function (orderParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getPlaceSpotOrderIx(orderParams)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getPlaceSpotOrderIx = function (orderParams) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        orderParams = this.getOrderParams(orderParams, types_1.MarketType.SPOT);
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            readableSpotMarketIndex: orderParams.marketIndex
+                        });
+                        _b = (_a = this.program.instruction).placeSpotOrder;
+                        _c = [orderParams];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.fillSpotOrder = function (userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getFillSpotOrderIx(userAccountPublicKey, user, order, fulfillmentConfig, makerInfo, referrerInfo)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getFillSpotOrderIx = function (userAccountPublicKey, userAccount, order, fulfillmentConfig, makerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userStatsPublicKey, fillerPublicKey, fillerStatsPublicKey, marketIndex, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap, _i, _a, spotPosition, spotMarket, _b, _c, position, market, spotMarketAccount, quoteMarketAccount, remainingAccounts, orderId, makerOrderId, _d, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        fillerPublicKey = _j.sent();
+                        fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
+                        marketIndex = order
+                            ? order.marketIndex
+                            : userAccount.orders.find(function (order) {
+                                return order.orderId.eq(userAccount.nextOrderId.sub(numericConstants_1.ONE));
+                            }).marketIndex;
+                        oracleAccountMap = new Map();
+                        spotMarketAccountMap = new Map();
+                        perpMarketAccountMap = new Map();
+                        for (_i = 0, _a = userAccount.spotPositions; _i < _a.length; _i++) {
+                            spotPosition = _a[_i];
+                            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                                spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+                                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                                    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 (_b = 0, _c = userAccount.perpPositions; _b < _c.length; _b++) {
+                            position = _c[_b];
+                            if (!(0, position_1.positionIsAvailable)(position) &&
+                                !position.marketIndex.eq(order.marketIndex)) {
+                                market = this.getPerpMarketAccount(position.marketIndex);
+                                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                                    pubkey: market.pubkey,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                                oracleAccountMap.set(market.amm.oracle.toString(), {
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        spotMarketAccountMap.set(marketIndex.toNumber(), {
+                            pubkey: spotMarketAccount.pubkey,
+                            isWritable: true,
+                            isSigner: false
+                        });
+                        if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey["default"])) {
+                            oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                                pubkey: spotMarketAccount.oracle,
+                                isWritable: false,
+                                isSigner: false
+                            });
+                        }
+                        quoteMarketAccount = this.getQuoteSpotMarketAccount();
+                        spotMarketAccountMap.set(quoteMarketAccount.marketIndex.toNumber(), {
+                            pubkey: quoteMarketAccount.pubkey,
+                            isWritable: true,
+                            isSigner: false
+                        });
+                        remainingAccounts = __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), perpMarketAccountMap.values(), true);
+                        if (makerInfo) {
+                            remainingAccounts.push({
+                                pubkey: makerInfo.maker,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: makerInfo.makerStats,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        if (referrerInfo) {
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrer,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrerStats,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        orderId = order.orderId;
+                        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: spotMarketAccount.vault,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: quoteMarketAccount.vault,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        _e = (_d = this.program.instruction).fillSpotOrder;
+                        _f = [orderId,
+                            fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null,
+                            makerOrderId];
+                        _g = {};
+                        _h = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _e.apply(_d, _f.concat([(_g.accounts = (_h.state = _j.sent(),
+                                _h.filler = fillerPublicKey,
+                                _h.fillerStats = fillerStatsPublicKey,
+                                _h.user = userAccountPublicKey,
+                                _h.userStats = userStatsPublicKey,
+                                _h.authority = this.wallet.publicKey,
+                                _h),
+                                _g.remainingAccounts = remainingAccounts,
+                                _g)]))];
+                    case 3: return [2 /*return*/, _j.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.triggerOrder = function (userAccountPublicKey, user, order) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getTriggerOrderIx(userAccountPublicKey, user, order)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getTriggerOrderIx = function (userAccountPublicKey, userAccount, order) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fillerPublicKey, marketIndex, marketAccount, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap, _i, _a, spotPosition, spotMarketAccount, _b, _c, position, market, remainingAccounts, orderId, _d, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        fillerPublicKey = _j.sent();
+                        marketIndex = order.marketIndex;
+                        marketAccount = this.getPerpMarketAccount(marketIndex);
+                        oracleAccountMap = new Map();
+                        spotMarketAccountMap = new Map();
+                        perpMarketAccountMap = new Map();
+                        for (_i = 0, _a = userAccount.spotPositions; _i < _a.length; _i++) {
+                            spotPosition = _a[_i];
+                            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                                spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                                    pubkey: spotMarketAccount.pubkey,
+                                    isSigner: false,
+                                    isWritable: false
+                                });
+                                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey["default"])) {
+                                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                                        pubkey: spotMarketAccount.oracle,
+                                        isSigner: false,
+                                        isWritable: false
+                                    });
+                                }
+                            }
+                        }
+                        for (_b = 0, _c = userAccount.perpPositions; _b < _c.length; _b++) {
+                            position = _c[_b];
+                            if (!(0, position_1.positionIsAvailable)(position) &&
+                                !position.marketIndex.eq(order.marketIndex)) {
+                                market = this.getPerpMarketAccount(position.marketIndex);
+                                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                                    pubkey: market.pubkey,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                                oracleAccountMap.set(market.amm.oracle.toString(), {
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        perpMarketAccountMap.set(marketIndex.toNumber(), {
+                            pubkey: marketAccount.pubkey,
+                            isWritable: true,
+                            isSigner: false
+                        });
+                        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                            pubkey: marketAccount.amm.oracle,
+                            isWritable: false,
+                            isSigner: false
+                        });
+                        remainingAccounts = __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), perpMarketAccountMap.values(), true);
+                        orderId = order.orderId;
+                        _e = (_d = this.program.instruction).triggerOrder;
+                        _f = [orderId];
+                        _g = {};
+                        _h = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _e.apply(_d, _f.concat([(_g.accounts = (_h.state = _j.sent(),
+                                _h.filler = fillerPublicKey,
+                                _h.user = userAccountPublicKey,
+                                _h.authority = this.wallet.publicKey,
+                                _h),
+                                _g.remainingAccounts = remainingAccounts,
+                                _g)]))];
+                    case 3: return [2 /*return*/, _j.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.triggerSpotOrder = function (userAccountPublicKey, user, order) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getTriggerSpotOrderIx(userAccountPublicKey, user, order)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getTriggerSpotOrderIx = function (userAccountPublicKey, userAccount, order) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fillerPublicKey, marketIndex, spotMarketAccount, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap, _i, _a, spotPosition, spotMarketAccount_2, _b, _c, position, market, quoteSpotMarket, remainingAccounts, orderId, _d, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        fillerPublicKey = _j.sent();
+                        marketIndex = order.marketIndex;
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        oracleAccountMap = new Map();
+                        spotMarketAccountMap = new Map();
+                        perpMarketAccountMap = new Map();
+                        for (_i = 0, _a = userAccount.spotPositions; _i < _a.length; _i++) {
+                            spotPosition = _a[_i];
+                            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                                spotMarketAccount_2 = this.getSpotMarketAccount(spotPosition.marketIndex);
+                                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                                    pubkey: spotMarketAccount_2.pubkey,
+                                    isSigner: false,
+                                    isWritable: false
+                                });
+                                if (!spotMarketAccount_2.oracle.equals(web3_js_1.PublicKey["default"])) {
+                                    oracleAccountMap.set(spotMarketAccount_2.oracle.toString(), {
+                                        pubkey: spotMarketAccount_2.oracle,
+                                        isSigner: false,
+                                        isWritable: false
+                                    });
+                                }
+                            }
+                        }
+                        for (_b = 0, _c = userAccount.perpPositions; _b < _c.length; _b++) {
+                            position = _c[_b];
+                            if (!(0, position_1.positionIsAvailable)(position) &&
+                                !position.marketIndex.eq(order.marketIndex)) {
+                                market = this.getPerpMarketAccount(position.marketIndex);
+                                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                                    pubkey: market.pubkey,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                                oracleAccountMap.set(market.amm.oracle.toString(), {
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        quoteSpotMarket = this.getQuoteSpotMarketAccount();
+                        spotMarketAccountMap.set(quoteSpotMarket.marketIndex.toNumber(), {
+                            pubkey: quoteSpotMarket.pubkey,
+                            isWritable: true,
+                            isSigner: false
+                        });
+                        spotMarketAccountMap.set(marketIndex.toNumber(), {
+                            pubkey: spotMarketAccount.pubkey,
+                            isWritable: false,
+                            isSigner: false
+                        });
+                        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                            pubkey: spotMarketAccount.oracle,
+                            isWritable: false,
+                            isSigner: false
+                        });
+                        remainingAccounts = __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), perpMarketAccountMap.values(), true);
+                        orderId = order.orderId;
+                        _e = (_d = this.program.instruction).triggerSpotOrder;
+                        _f = [orderId];
+                        _g = {};
+                        _h = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _e.apply(_d, _f.concat([(_g.accounts = (_h.state = _j.sent(),
+                                _h.filler = fillerPublicKey,
+                                _h.user = userAccountPublicKey,
+                                _h.authority = this.wallet.publicKey,
+                                _h),
+                                _g.remainingAccounts = remainingAccounts,
+                                _g)]))];
+                    case 3: return [2 /*return*/, _j.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.placeAndTake = function (orderParams, makerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getPlaceAndTakeIx(orderParams, makerInfo, referrerInfo)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getPlaceAndTakeIx = function (orderParams, makerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userStatsPublicKey, userAccountPublicKey, remainingAccounts, makerOrderId, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+                        return [4 /*yield*/, this.getUserStatsAccountPublicKey()];
+                    case 1:
+                        userStatsPublicKey = _f.sent();
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 2:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccounts({
+                            writablePerpMarketIndex: orderParams.marketIndex,
+                            writableSpotMarketIndex: numericConstants_1.QUOTE_SPOT_MARKET_INDEX
+                        });
+                        makerOrderId = null;
+                        if (makerInfo) {
+                            makerOrderId = makerInfo.order.orderId;
+                            remainingAccounts.push({
+                                pubkey: makerInfo.maker,
+                                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
+                            });
+                        }
+                        _b = (_a = this.program.instruction).placeAndTake;
+                        _c = [orderParams,
+                            makerOrderId];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 3: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.userStats = userStatsPublicKey,
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 4: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.placeAndMake = function (orderParams, takerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getPlaceAndMakeIx(orderParams, takerInfo, referrerInfo)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getPlaceAndMakeIx = function (orderParams, takerInfo, referrerInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userStatsPublicKey, userAccountPublicKey, remainingAccounts, takerOrderId, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        orderParams = this.getOrderParams(orderParams, types_1.MarketType.PERP);
+                        userStatsPublicKey = this.getUserStatsAccountPublicKey();
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        userAccountPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            counterPartyUserAccount: takerInfo.takerUserAccount,
+                            writablePerpMarketIndex: orderParams.marketIndex
+                        });
+                        if (referrerInfo) {
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrer,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                            remainingAccounts.push({
+                                pubkey: referrerInfo.referrerStats,
+                                isWritable: true,
+                                isSigner: false
+                            });
+                        }
+                        takerOrderId = takerInfo.order.orderId;
+                        _b = (_a = this.program.instruction).placeAndMake;
+                        _c = [orderParams,
+                            takerOrderId];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.user = userAccountPublicKey,
+                                _e.userStats = userStatsPublicKey,
+                                _e.taker = takerInfo.taker,
+                                _e.takerStats = takerInfo.takerStats,
+                                _e.authority = this.wallet.publicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
+     * @param marketIndex
+     * @returns
+     */
+    ClearingHouse.prototype.closePosition = function (marketIndex, limitPrice) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userPosition;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        userPosition = this.getUser().getUserPosition(marketIndex);
+                        if (!userPosition) {
+                            throw Error("No position in market ".concat(marketIndex.toString()));
+                        }
+                        return [4 /*yield*/, this.placeAndTake({
+                                orderType: types_1.OrderType.MARKET,
+                                marketIndex: marketIndex,
+                                direction: (0, position_1.findDirectionToClose)(userPosition),
+                                baseAssetAmount: userPosition.baseAssetAmount.abs(),
+                                reduceOnly: true,
+                                price: limitPrice
+                            })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settlePNLs = function (users, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ixs, _i, users_1, _a, settleeUserAccountPublicKey, settleeUserAccount, _b, _c, tx, txSig;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        ixs = [];
+                        _i = 0, users_1 = users;
+                        _e.label = 1;
+                    case 1:
+                        if (!(_i < users_1.length)) return [3 /*break*/, 4];
+                        _a = users_1[_i], settleeUserAccountPublicKey = _a.settleeUserAccountPublicKey, settleeUserAccount = _a.settleeUserAccount;
+                        _c = (_b = ixs).push;
+                        return [4 /*yield*/, this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex)];
+                    case 2:
+                        _c.apply(_b, [_e.sent()]);
+                        _e.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        tx = (_d = new web3_js_1.Transaction()
+                            .add(web3_js_1.ComputeBudgetProgram.requestUnits({
+                            units: 1000000,
+                            additionalFee: 0
+                        })))
+                            .add.apply(_d, ixs);
+                        return [4 /*yield*/, this.txSender.send(tx, [], this.opts)];
+                    case 5:
+                        txSig = (_e.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settlePNL = function (settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settlePNLIx = function (settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var perpMarketAccountMap, oracleAccountMap, spotMarketAccountMap, _i, _a, position, market, _b, _c, spotPosition, spotMarketAccount, marketAccount, remainingAccounts, _d, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        perpMarketAccountMap = new Map();
+                        oracleAccountMap = new Map();
+                        spotMarketAccountMap = new Map();
+                        for (_i = 0, _a = settleeUserAccount.perpPositions; _i < _a.length; _i++) {
+                            position = _a[_i];
+                            if (!(0, position_1.positionIsAvailable)(position)) {
+                                market = this.getPerpMarketAccount(position.marketIndex);
+                                perpMarketAccountMap.set(position.marketIndex.toNumber(), {
+                                    pubkey: market.pubkey,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                                oracleAccountMap.set(market.amm.oracle.toString(), {
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        for (_b = 0, _c = settleeUserAccount.spotPositions; _b < _c.length; _b++) {
+                            spotPosition = _c[_b];
+                            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                                spotMarketAccount = this.getSpotMarketAccount(spotPosition.marketIndex);
+                                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                                    pubkey: spotMarketAccount.pubkey,
+                                    isSigner: false,
+                                    isWritable: false
+                                });
+                                if (!spotMarketAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                                        pubkey: spotMarketAccount.oracle,
+                                        isSigner: false,
+                                        isWritable: false
+                                    });
+                                }
+                            }
+                        }
+                        marketAccount = this.getPerpMarketAccount(marketIndex.toNumber());
+                        perpMarketAccountMap.set(marketIndex.toNumber(), {
+                            pubkey: marketAccount.pubkey,
+                            isSigner: false,
+                            isWritable: true
+                        });
+                        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                            pubkey: marketAccount.amm.oracle,
+                            isSigner: false,
+                            isWritable: false
+                        });
+                        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX.toNumber(), {
+                            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
+                            isSigner: false,
+                            isWritable: true
+                        });
+                        remainingAccounts = __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), perpMarketAccountMap.values(), true);
+                        _e = (_d = this.program.instruction).settlePnl;
+                        _f = [marketIndex];
+                        _g = {};
+                        _h = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _e.apply(_d, _f.concat([(_g.accounts = (_h.state = _j.sent(),
+                                _h.authority = this.wallet.publicKey,
+                                _h.user = settleeUserAccountPublicKey,
+                                _h),
+                                _g.remainingAccounts = remainingAccounts,
+                                _g)]))];
+                    case 2: return [2 /*return*/, _j.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settleExpiredPosition = function (settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getSettleExpiredPositionIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getSettleExpiredPositionIx = function (settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var marketAccountMap, oracleAccountMap, spotMarketAccountMap, _i, _a, position, market, _b, _c, userBankBalance, bankAccount, marketAccount, remainingAccounts, _d, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        marketAccountMap = new Map();
+                        oracleAccountMap = new Map();
+                        spotMarketAccountMap = new Map();
+                        for (_i = 0, _a = settleeUserAccount.perpPositions; _i < _a.length; _i++) {
+                            position = _a[_i];
+                            if (!(0, position_1.positionIsAvailable)(position)) {
+                                market = this.getPerpMarketAccount(position.marketIndex);
+                                marketAccountMap.set(position.marketIndex.toNumber(), {
+                                    pubkey: market.pubkey,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                                oracleAccountMap.set(market.amm.oracle.toString(), {
+                                    pubkey: market.amm.oracle,
+                                    isWritable: false,
+                                    isSigner: false
+                                });
+                            }
+                        }
+                        for (_b = 0, _c = settleeUserAccount.spotPositions; _b < _c.length; _b++) {
+                            userBankBalance = _c[_b];
+                            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
+                                bankAccount = this.getSpotMarketAccount(userBankBalance.marketIndex);
+                                spotMarketAccountMap.set(userBankBalance.marketIndex.toNumber(), {
+                                    pubkey: bankAccount.pubkey,
+                                    isSigner: false,
+                                    isWritable: false
+                                });
+                                if (!bankAccount.marketIndex.eq(numericConstants_1.ZERO)) {
+                                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                                        pubkey: bankAccount.oracle,
+                                        isSigner: false,
+                                        isWritable: false
+                                    });
+                                }
+                            }
+                        }
+                        marketAccount = this.getPerpMarketAccount(marketIndex.toNumber());
+                        marketAccountMap.set(marketIndex.toNumber(), {
+                            pubkey: marketAccount.pubkey,
+                            isSigner: false,
+                            isWritable: true
+                        });
+                        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                            pubkey: marketAccount.amm.oracle,
+                            isSigner: false,
+                            isWritable: false
+                        });
+                        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX.toNumber(), {
+                            pubkey: this.getSpotMarketAccount(numericConstants_1.QUOTE_SPOT_MARKET_INDEX).pubkey,
+                            isSigner: false,
+                            isWritable: true
+                        });
+                        remainingAccounts = __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), marketAccountMap.values(), true);
+                        _e = (_d = this.program.instruction).settleExpiredPosition;
+                        _f = [marketIndex];
+                        _g = {};
+                        _h = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _e.apply(_d, _f.concat([(_g.accounts = (_h.state = _j.sent(),
+                                _h.authority = this.wallet.publicKey,
+                                _h.user = settleeUserAccountPublicKey,
+                                _h),
+                                _g.remainingAccounts = remainingAccounts,
+                                _g)]))];
+                    case 2: return [2 /*return*/, _j.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.liquidatePerp = function (userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getLiquidatePerpIx = function (userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userStatsPublicKey, liquidatorPublicKey, liquidatorStatsPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
+                        return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        liquidatorPublicKey = _f.sent();
+                        liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            writablePerpMarketIndex: marketIndex,
+                            counterPartyUserAccount: userAccount
+                        });
+                        _b = (_a = this.program.instruction).liquidatePerp;
+                        _c = [marketIndex,
+                            maxBaseAssetAmount];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.user = userAccountPublicKey,
+                                _e.userStats = userStatsPublicKey,
+                                _e.liquidator = liquidatorPublicKey,
+                                _e.liquidatorStats = liquidatorStatsPublicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.liquidateBorrow = function (userAccountPublicKey, userAccount, assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getLiquidateBorrowIx = function (userAccountPublicKey, userAccount, assetmarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var liquidatorPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        liquidatorPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            counterPartyUserAccount: userAccount,
+                            writableSpotMarketIndexes: [liabilitymarketIndex, assetmarketIndex]
+                        });
+                        _b = (_a = this.program.instruction).liquidateBorrow;
+                        _c = [assetmarketIndex,
+                            liabilitymarketIndex,
+                            maxLiabilityTransfer];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.user = userAccountPublicKey,
+                                _e.liquidator = liquidatorPublicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.liquidateBorrowForPerpPnl = function (userAccountPublicKey, userAccount, perpMarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilitymarketIndex, maxLiabilityTransfer)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(perpMarketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getLiquidateBorrowForPerpPnlIx = function (userAccountPublicKey, userAccount, perpMarketIndex, liabilitymarketIndex, maxLiabilityTransfer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var liquidatorPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        liquidatorPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            counterPartyUserAccount: userAccount,
+                            writablePerpMarketIndex: perpMarketIndex,
+                            writableSpotMarketIndexes: [liabilitymarketIndex]
+                        });
+                        _b = (_a = this.program.instruction).liquidateBorrowForPerpPnl;
+                        _c = [perpMarketIndex,
+                            liabilitymarketIndex,
+                            maxLiabilityTransfer];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.user = userAccountPublicKey,
+                                _e.liquidator = liquidatorPublicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.liquidatePerpPnlForDeposit = function (userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, txSig, slot, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _c = (_b = this.txSender).send;
+                        _d = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer)];
+                    case 1: return [4 /*yield*/, _c.apply(_b, [_d.apply(void 0, [_e.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        _a = _e.sent(), txSig = _a.txSig, slot = _a.slot;
+                        this.marketLastSlotCache.set(perpMarketIndex.toNumber(), slot);
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getLiquidatePerpPnlForDepositIx = function (userAccountPublicKey, userAccount, perpMarketIndex, assetMarketIndex, maxPnlTransfer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var liquidatorPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        liquidatorPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            counterPartyUserAccount: userAccount,
+                            writablePerpMarketIndex: perpMarketIndex,
+                            writableSpotMarketIndexes: [assetMarketIndex]
+                        });
+                        _b = (_a = this.program.instruction).liquidatePerpPnlForDeposit;
+                        _c = [perpMarketIndex,
+                            assetMarketIndex,
+                            maxPnlTransfer];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.user = userAccountPublicKey,
+                                _e.liquidator = liquidatorPublicKey,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.resolvePerpBankruptcy = function (userAccountPublicKey, userAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getResolvePerpBankruptcyIx = function (userAccountPublicKey, userAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var liquidatorPublicKey, remainingAccounts, spotMarket, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        liquidatorPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            writablePerpMarketIndex: marketIndex,
+                            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+                            counterPartyUserAccount: userAccount
+                        });
+                        spotMarket = this.getSpotMarketAccount(marketIndex);
+                        _b = (_a = this.program.instruction).resolvePerpBankruptcy;
+                        _c = [numericConstants_1.QUOTE_SPOT_MARKET_INDEX,
+                            marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.user = userAccountPublicKey,
+                                _e.liquidator = liquidatorPublicKey,
+                                _e.spotMarketVault = spotMarket.vault,
+                                _e.insuranceFundVault = spotMarket.insuranceFundVault,
+                                _e.clearingHouseSigner = this.getSignerPublicKey(),
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.resolveBorrowBankruptcy = function (userAccountPublicKey, userAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getResolveBorrowBankruptcyIx = function (userAccountPublicKey, userAccount, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var liquidatorPublicKey, remainingAccounts, spotMarket, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.getUserAccountPublicKey()];
+                    case 1:
+                        liquidatorPublicKey = _f.sent();
+                        remainingAccounts = this.getRemainingAccountsWithCounterparty({
+                            writableSpotMarketIndexes: [marketIndex],
+                            counterPartyUserAccount: userAccount
+                        });
+                        spotMarket = this.getSpotMarketAccount(marketIndex);
+                        _b = (_a = this.program.instruction).resolveBorrowBankruptcy;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.user = userAccountPublicKey,
+                                _e.liquidator = liquidatorPublicKey,
+                                _e.spotMarketVault = spotMarket.vault,
+                                _e.insuranceFundVault = spotMarket.insuranceFundVault,
+                                _e.clearingHouseSigner = this.getSignerPublicKey(),
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getRemainingAccountsWithCounterparty = function (params) {
+        var counterPartyUserAccount = params.counterPartyUserAccount;
+        var oracleAccountMap = new Map();
+        var spotMarketAccountMap = new Map();
+        var marketAccountMap = new Map();
+        for (var _i = 0, _a = counterPartyUserAccount.spotPositions; _i < _a.length; _i++) {
+            var spotPosition = _a[_i];
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                var spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    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 (var _b = 0, _c = counterPartyUserAccount.perpPositions; _b < _c.length; _b++) {
+            var position = _c[_b];
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                var market = this.getPerpMarketAccount(position.marketIndex);
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
+                    isSigner: false
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false
+                });
+            }
+        }
+        var userAccountAndSlot = this.getUserAccountAndSlot();
+        if (!userAccountAndSlot) {
+            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
+        }
+        var userAccount = userAccountAndSlot.data, lastUserPositionsSlot = userAccountAndSlot.slot;
+        for (var _d = 0, _e = this.marketLastSlotCache.entries(); _d < _e.length; _d++) {
+            var _f = _e[_d], marketIndexNum = _f[0], slot = _f[1];
+            // if cache has more recent slot than user positions account slot, add market to remaining accounts
+            // otherwise remove from slot
+            if (slot > lastUserPositionsSlot) {
+                var marketAccount = this.getPerpMarketAccount(marketIndexNum);
+                marketAccountMap.set(marketIndexNum, {
+                    pubkey: marketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: false
+                });
+                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                    pubkey: marketAccount.amm.oracle,
+                    isSigner: false,
+                    isWritable: false
+                });
+            }
+            else {
+                this.marketLastSlotCache["delete"](marketIndexNum);
+            }
+        }
+        for (var _g = 0, _h = userAccount.spotPositions; _g < _h.length; _g++) {
+            var spotPosition = _h[_g];
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                var spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+                spotMarketAccountMap.set(spotPosition.marketIndex.toNumber(), {
+                    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 (var _j = 0, _k = userAccount.perpPositions; _j < _k.length; _j++) {
+            var position = _k[_j];
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                var market = this.getPerpMarketAccount(position.marketIndex);
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
+                    isSigner: false
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false
+                });
+            }
+        }
+        if (params.writablePerpMarketIndex) {
+            var market = this.getPerpMarketAccount(params.writablePerpMarketIndex);
+            marketAccountMap.set(market.marketIndex.toNumber(), {
+                pubkey: market.pubkey,
+                isSigner: false,
+                isWritable: true
+            });
+            oracleAccountMap.set(market.amm.oracle.toString(), {
+                pubkey: market.amm.oracle,
+                isSigner: false,
+                isWritable: false
+            });
+        }
+        if (params.writableSpotMarketIndexes) {
+            for (var _l = 0, _m = params.writableSpotMarketIndexes; _l < _m.length; _l++) {
+                var writableSpotMarketIndex = _m[_l];
+                var spotMarketAccount = this.getSpotMarketAccount(writableSpotMarketIndex);
+                spotMarketAccountMap.set(spotMarketAccount.marketIndex.toNumber(), {
+                    pubkey: spotMarketAccount.pubkey,
+                    isSigner: false,
+                    isWritable: true
+                });
+                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey["default"])) {
+                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                        pubkey: spotMarketAccount.oracle,
+                        isSigner: false,
+                        isWritable: false
+                    });
+                }
+            }
+        }
+        return __spreadArray(__spreadArray(__spreadArray([], oracleAccountMap.values(), true), spotMarketAccountMap.values(), true), marketAccountMap.values(), true);
+    };
+    ClearingHouse.prototype.updateFundingRate = function (oracle, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getUpdateFundingRateIx(oracle, marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getUpdateFundingRateIx = function (oracle, marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        _b = (_a = this.program.instruction).updateFundingRate;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1:
+                        _e.state = _f.sent();
+                        return [4 /*yield*/, (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex)];
+                    case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.market = _f.sent(),
+                                _e.oracle = oracle,
+                                _e),
+                                _d)]))];
+                    case 3: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settleFundingPayment = function (userAccount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getSettleFundingPaymentIx(userAccount)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getSettleFundingPaymentIx = function (userAccount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var user, userPositions, remainingAccounts, _i, userPositions_2, position, marketPublicKey, _a, _b;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.program.account.user.fetch(userAccount)];
+                    case 1:
+                        user = (_e.sent());
+                        userPositions = user.perpPositions;
+                        remainingAccounts = [];
+                        _i = 0, userPositions_2 = userPositions;
+                        _e.label = 2;
+                    case 2:
+                        if (!(_i < userPositions_2.length)) return [3 /*break*/, 5];
+                        position = userPositions_2[_i];
+                        if (!!(0, position_1.positionIsAvailable)(position)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex)];
+                    case 3:
+                        marketPublicKey = _e.sent();
+                        remainingAccounts.push({
+                            pubkey: marketPublicKey,
+                            isWritable: false,
+                            isSigner: false
+                        });
+                        _e.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        _b = (_a = this.program.instruction).settleFundingPayment;
+                        _c = {};
+                        _d = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 6: return [4 /*yield*/, _b.apply(_a, [(_c.accounts = (_d.state = _e.sent(),
+                                _d.user = userAccount,
+                                _d),
+                                _c.remainingAccounts = remainingAccounts,
+                                _c)])];
+                    case 7: return [2 /*return*/, _e.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.triggerEvent = function (eventName, data) {
+        this.eventEmitter.emit(eventName, data);
+    };
+    ClearingHouse.prototype.getOracleDataForMarket = function (marketIndex) {
+        var oracleKey = this.getPerpMarketAccount(marketIndex).amm.oracle;
+        var oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
+    };
+    ClearingHouse.prototype.initializeInsuranceFundStake = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getInitializeInsuranceFundStakeIx(marketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getInitializeInsuranceFundStakeIx = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ifStakeAccountPublicKey, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+                        _b = (_a = this.program.instruction).initializeInsuranceFundStake;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {
+                            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
+                        };
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e),
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.addInsuranceFundStake = function (marketIndex, amount, collateralAccountPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spotMarket, ifStakeAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        spotMarket = this.getSpotMarketAccount(marketIndex);
+                        ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.rpc).addInsuranceFundStake;
+                        _c = [marketIndex, amount];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.spotMarket = spotMarket.pubkey,
+                                _e.insuranceFundStake = ifStakeAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.insuranceFundVault = spotMarket.insuranceFundVault,
+                                _e.userTokenAccount = collateralAccountPublicKey,
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.requestRemoveInsuranceFundStake = function (marketIndex, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spotMarketAccount, ifStakeAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.rpc).requestRemoveInsuranceFundStake;
+                        _c = [marketIndex,
+                            amount];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.spotMarket = spotMarketAccount.pubkey,
+                                _e.insuranceFundStake = ifStakeAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.insuranceFundVault = spotMarketAccount.insuranceFundVault,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.cancelRequestRemoveInsuranceFundStake = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spotMarketAccount, ifStakeAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.rpc).cancelRequestRemoveInsuranceFundStake;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.spotMarket = spotMarketAccount.pubkey,
+                                _e.insuranceFundStake = ifStakeAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.insuranceFundVault = spotMarketAccount.insuranceFundVault,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.removeInsuranceFundStake = function (marketIndex, collateralAccountPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spotMarketAccount, ifStakeAccountPublicKey, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, marketIndex);
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.rpc).removeInsuranceFundStake;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.spotMarket = spotMarketAccount.pubkey,
+                                _e.insuranceFundStake = ifStakeAccountPublicKey,
+                                _e.userStats = this.getUserStatsAccountPublicKey(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.insuranceFundVault = spotMarketAccount.insuranceFundVault,
+                                _e.clearingHouseSigner = this.getSignerPublicKey(),
+                                _e.userTokenAccount = collateralAccountPublicKey,
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.settleRevenueToInsuranceFund = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spotMarketAccount, remainingAccounts, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+                        remainingAccounts = this.getRemainingAccounts({
+                            writableSpotMarketIndex: marketIndex
+                        });
+                        _b = (_a = this.program.rpc).settleRevenueToInsuranceFund;
+                        _c = [marketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.spotMarket = spotMarketAccount.pubkey,
+                                _e.spotMarketVault = spotMarketAccount.vault,
+                                _e.clearingHouseSigner = this.getSignerPublicKey(),
+                                _e.insuranceFundVault = spotMarketAccount.insuranceFundVault,
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.resolvePerpPnlDeficit = function (spotMarketIndex, perpMarketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txSig, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.txSender).send;
+                        _c = utils_1.wrapInTx;
+                        return [4 /*yield*/, this.getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_c.apply(void 0, [_d.sent()]),
+                            [],
+                            this.opts])];
+                    case 2:
+                        txSig = (_d.sent()).txSig;
+                        return [2 /*return*/, txSig];
+                }
+            });
+        });
+    };
+    ClearingHouse.prototype.getResolvePerpPnlDeficitIx = function (spotMarketIndex, perpMarketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var remainingAccounts, spotMarket, _a, _b, _c;
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        remainingAccounts = this.getRemainingAccounts({
+                            writablePerpMarketIndex: perpMarketIndex,
+                            writableSpotMarketIndex: spotMarketIndex
+                        });
+                        spotMarket = this.getSpotMarketAccount(spotMarketIndex);
+                        _b = (_a = this.program.instruction).resolvePerpPnlDeficit;
+                        _c = [spotMarketIndex,
+                            perpMarketIndex];
+                        _d = {};
+                        _e = {};
+                        return [4 /*yield*/, this.getStatePublicKey()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.accounts = (_e.state = _f.sent(),
+                                _e.authority = this.wallet.publicKey,
+                                _e.spotMarketVault = spotMarket.vault,
+                                _e.insuranceFundVault = spotMarket.insuranceFundVault,
+                                _e.clearingHouseSigner = this.getSignerPublicKey(),
+                                _e.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID,
+                                _e),
+                                _d.remainingAccounts = remainingAccounts,
+                                _d)]))];
+                    case 2: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    return ClearingHouse;
+}());
+exports.ClearingHouse = ClearingHouse;