@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.0

package/lib/clearingHouse.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -41,30 +32,62 @@ const spl_token_1 = require("@solana/spl-token");
 const anchor = __importStar(require("@project-serum/anchor"));
 const clearing_house_json_1 = __importDefault(require("./idl/clearing_house.json"));
 const web3_js_1 = require("@solana/web3.js");
-const addresses_1 = require("./addresses");
+const pda_1 = require("./addresses/pda");
 const utils_1 = require("./tx/utils");
-const clearingHouse_1 = require("./factory/clearingHouse");
 const numericConstants_1 = require("./constants/numericConstants");
-const bulkAccountLoader_1 = require("./accounts/bulkAccountLoader");
-const clearingHouseUser_1 = require("./factory/clearingHouseUser");
-const bulkUserSubscription_1 = require("./accounts/bulkUserSubscription");
+const position_1 = require("./math/position");
+const bankBalance_1 = require("./math/bankBalance");
+const userName_1 = require("./userName");
+const pollingClearingHouseAccountSubscriber_1 = require("./accounts/pollingClearingHouseAccountSubscriber");
+const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketClearingHouseAccountSubscriber");
+const retryTxSender_1 = require("./tx/retryTxSender");
+const clearingHouseUser_1 = require("./clearingHouseUser");
+const orderParams_1 = require("./orderParams");
+const config_1 = require("./config");
 /**
  * # 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.
- *
- * The default way to construct a ClearingHouse instance is using the {@link from} method. This will create an instance using the static {@link WebSocketClearingHouseAccountSubscriber}, which will use a websocket for each state account subscription.
- * Alternatively, if you want to implement your own method of subscribing to the state accounts on the blockchain, you can implement a {@link ClearingHouseAccountSubscriber} and use it in the {@link ClearingHouse.constructor}
  */
 class ClearingHouse {
-    constructor(connection, wallet, program, accountSubscriber, txSender, opts) {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.users = new Map();
         this._isSubscribed = false;
-        this.connection = connection;
-        this.wallet = wallet;
-        this.opts = opts;
-        this.program = program;
-        this.accountSubscriber = accountSubscriber;
+        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);
+        const 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);
+        let marketIndexes = config.marketIndexes;
+        let bankIndexes = config.bankIndexes;
+        let oracleInfos = config.oracleInfos;
+        if (config.env) {
+            const { marketIndexes: envMarketIndexes, bankIndexes: envBankIndexes, oracleInfos: envOralceInfos, } = (0, config_1.getMarketsBanksAndOraclesForSubscription)(config.env);
+            marketIndexes = marketIndexes ? marketIndexes : envMarketIndexes;
+            bankIndexes = bankIndexes ? bankIndexes : envBankIndexes;
+            oracleInfos = oracleInfos ? oracleInfos : envOralceInfos;
+        }
+        if (((_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.type) === 'polling') {
+            this.accountSubscriber = new pollingClearingHouseAccountSubscriber_1.PollingClearingHouseAccountSubscriber(this.program, config.accountSubscription.accountLoader, marketIndexes !== null && marketIndexes !== void 0 ? marketIndexes : [], bankIndexes !== null && bankIndexes !== void 0 ? bankIndexes : [], oracleInfos !== null && oracleInfos !== void 0 ? oracleInfos : []);
+        }
+        else {
+            this.accountSubscriber = new webSocketClearingHouseAccountSubscriber_1.WebSocketClearingHouseAccountSubscriber(this.program, (_e = config.marketIndexes) !== null && _e !== void 0 ? _e : [], (_f = config.bankIndexes) !== null && _f !== void 0 ? _f : [], (_g = config.oracleInfos) !== null && _g !== void 0 ? _g : []);
+        }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
-        this.txSender = txSender;
+        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);
     }
     get isSubscribed() {
         return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -72,128 +95,82 @@ class ClearingHouse {
     set isSubscribed(val) {
         this._isSubscribed = val;
     }
-    /**
-     * @deprecated You should use the getClearingHouse factory method instead
-     * @param connection
-     * @param wallet
-     * @param clearingHouseProgramId
-     * @param opts
-     * @returns
-     */
-    static from(connection, wallet, clearingHouseProgramId, opts = anchor_1.AnchorProvider.defaultOptions()) {
-        const config = (0, clearingHouse_1.getWebSocketClearingHouseConfig)(connection, wallet, clearingHouseProgramId, opts);
-        return (0, clearingHouse_1.getClearingHouse)(config);
+    createUsers(userIds, accountSubscriptionConfig) {
+        for (const userId of userIds) {
+            const user = this.createUser(userId, accountSubscriptionConfig);
+            this.users.set(userId, user);
+        }
     }
-    /**
-     *
-     * @param optionalSubscriptions - Optional extra accounts to subcribe to. Always subscribes to base clearing house state and market account state by default. You should only subscribe to optional extra accounts if required, to avoid overloading your RPC.
-     * @returns Promise<boolean> : SubscriptionSuccess
-     */
-    subscribe(optionalSubscriptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.isSubscribed = yield this.accountSubscriber.subscribe(optionalSubscriptions);
-            return this.isSubscribed;
+    createUser(userId, accountSubscriptionConfig) {
+        const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, userId);
+        return new clearingHouseUser_1.ClearingHouseUser({
+            clearingHouse: this,
+            userAccountPublicKey,
+            accountSubscription: accountSubscriptionConfig,
         });
     }
-    /**
-     * Shorthand function to subscribe to all available Clearing House State Accounts
-     * @returns Promise<boolean> : SubscriptionSuccess
-     */
-    subscribeToAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.subscribe([
-                'curveHistoryAccount',
-                'depositHistoryAccount',
-                'fundingPaymentHistoryAccount',
-                'fundingRateHistoryAccount',
-                'liquidationHistoryAccount',
-                'tradeHistoryAccount',
-                'orderHistoryAccount',
-            ]);
-        });
+    async subscribe() {
+        const subscribePromises = this.subscribeUsers().concat(this.accountSubscriber.subscribe());
+        this.isSubscribed = (await Promise.all(subscribePromises)).reduce((success, prevSuccess) => success && prevSuccess);
+        return this.isSubscribed;
     }
-    /**
-     *	Forces the accountSubscriber to fetch account updates from rpc
-     */
-    fetchAccounts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.accountSubscriber.fetch();
-        });
+    subscribeUsers() {
+        return [...this.users.values()].map((user) => user.subscribe());
     }
     /**
-     * Unsubscribe from all currently subscribed state accounts
+     *	Forces the accountSubscriber to fetch account updates from rpc
      */
-    unsubscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.accountSubscriber.unsubscribe();
-            this.isSubscribed = false;
-        });
+    async fetchAccounts() {
+        await Promise.all([...this.users.values()]
+            .map((user) => user.fetchAccounts())
+            .concat(this.accountSubscriber.fetch()));
     }
-    getStatePublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.statePublicKey) {
-                return this.statePublicKey;
-            }
-            this.statePublicKey = yield (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-            return this.statePublicKey;
-        });
-    }
-    getStateAccount() {
-        return this.accountSubscriber.getStateAccount();
-    }
-    getSettlementAccount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
-            return yield this.program.account.settlementState.fetch(yield (0, addresses_1.getSettlementStatePublicKey)(this.program.programId));
-        });
+    async unsubscribe() {
+        const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
+        await Promise.all(unsubscribePromises);
+        this.isSubscribed = false;
     }
-    getMarketsAccount() {
-        return this.accountSubscriber.getMarketsAccount();
+    unsubscribeUsers() {
+        return [...this.users.values()].map((user) => user.unsubscribe());
     }
-    getMarket(marketIndex) {
-        if (marketIndex instanceof anchor_1.BN) {
-            marketIndex = marketIndex.toNumber();
+    async getStatePublicKey() {
+        if (this.statePublicKey) {
+            return this.statePublicKey;
         }
-        return this.getMarketsAccount().markets[marketIndex];
-    }
-    getFundingPaymentHistoryAccount() {
-        return this.accountSubscriber.getFundingPaymentHistoryAccount();
-    }
-    getFundingRateHistoryAccount() {
-        return this.accountSubscriber.getFundingRateHistoryAccount();
-    }
-    getTradeHistoryAccount() {
-        return this.accountSubscriber.getTradeHistoryAccount();
+        this.statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
+        return this.statePublicKey;
     }
-    getLiquidationHistoryAccount() {
-        return this.accountSubscriber.getLiquidationHistoryAccount();
+    getStateAccount() {
+        return this.accountSubscriber.getStateAccountAndSlot().data;
     }
-    getDepositHistoryAccount() {
-        return this.accountSubscriber.getDepositHistoryAccount();
+    getMarketAccount(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;
     }
-    getCurveHistoryAccount() {
-        return this.accountSubscriber.getCurveHistoryAccount();
+    getMarketAccounts() {
+        return this.accountSubscriber
+            .getMarketAccountsAndSlots()
+            .map((value) => value.data);
     }
-    getOrderHistoryAccount() {
-        return this.accountSubscriber.getOrderHistoryAccount();
+    getBankAccount(bankIndex) {
+        bankIndex = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
+        return this.accountSubscriber.getBankAccountAndSlot(bankIndex).data;
     }
-    getOrderStatePublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.orderStatePublicKey) {
-                return this.orderStatePublicKey;
-            }
-            this.orderStatePublicKey = yield (0, addresses_1.getOrderStateAccountPublicKey)(this.program.programId);
-            return this.orderStatePublicKey;
-        });
+    getQuoteAssetBankAccount() {
+        return this.accountSubscriber.getBankAccountAndSlot(numericConstants_1.QUOTE_ASSET_BANK_INDEX)
+            .data;
     }
-    getOrderStateAccount() {
-        return this.accountSubscriber.getOrderStateAccount();
+    getOraclePriceDataAndSlot(oraclePublicKey) {
+        return this.accountSubscriber.getOraclePriceDataAndSlot(oraclePublicKey);
     }
     /**
      * Update the wallet to use for clearing house transactions and linked user account
      * @param newWallet
+     * @param userIds
+     * @param activeUserId
      */
-    updateWallet(newWallet) {
+    async updateWallet(newWallet, userIds = [0], activeUserId = 0) {
         const newProvider = new anchor_1.AnchorProvider(this.connection, newWallet, this.opts);
         const newProgram = new anchor_1.Program(clearing_house_json_1.default, this.program.programId, newProvider);
         // Update provider for txSender with new wallet details
@@ -201,852 +178,754 @@ class ClearingHouse {
         this.wallet = newWallet;
         this.provider = newProvider;
         this.program = newProgram;
-        this.userAccountPublicKey = undefined;
-        this.userAccount = undefined;
-        this.userOrdersAccountPublicKey = undefined;
-        this.userOrdersExist = undefined;
-    }
-    initializeUserAccount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [userPositionsAccount, userAccountPublicKey, initializeUserAccountIx, initializeUserOrdersAccountIx,] = yield this.getInitializeUserInstructions();
-            const tx = new web3_js_1.Transaction()
-                .add(initializeUserAccountIx)
-                .add(initializeUserOrdersAccountIx);
-            const txSig = yield this.txSender.send(tx, [userPositionsAccount], this.opts);
-            return [txSig, userAccountPublicKey];
-        });
-    }
-    getInitializeUserInstructions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [userAccountPublicKey, userAccountNonce] = yield (0, addresses_1.getUserAccountPublicKeyAndNonce)(this.program.programId, this.wallet.publicKey);
-            const remainingAccounts = [];
-            const optionalAccounts = {
-                whitelistToken: false,
-            };
-            const state = this.getStateAccount();
-            if (state.whitelistMint) {
-                optionalAccounts.whitelistToken = true;
-                const associatedTokenPublicKey = yield spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.whitelistMint, this.wallet.publicKey);
-                remainingAccounts.push({
-                    pubkey: associatedTokenPublicKey,
-                    isWritable: false,
-                    isSigner: false,
-                });
-            }
-            const userPositions = new web3_js_1.Keypair();
-            const initializeUserAccountIx = yield this.program.instruction.initializeUser(userAccountNonce, optionalAccounts, {
-                accounts: {
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-                    systemProgram: anchor.web3.SystemProgram.programId,
-                    userPositions: userPositions.publicKey,
-                    state: yield this.getStatePublicKey(),
-                },
-                remainingAccounts: remainingAccounts,
-            });
-            const initializeUserOrdersAccountIx = yield this.getInitializeUserOrdersInstruction(userAccountPublicKey);
-            return [
-                userPositions,
-                userAccountPublicKey,
-                initializeUserAccountIx,
-                initializeUserOrdersAccountIx,
-            ];
-        });
-    }
-    getInitializeUserOrdersInstruction(userAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!userAccountPublicKey) {
-                userAccountPublicKey = yield this.getUserAccountPublicKey();
-            }
-            const [userOrdersAccountPublicKey, userOrdersAccountNonce] = yield (0, addresses_1.getUserOrdersAccountPublicKeyAndNonce)(this.program.programId, userAccountPublicKey);
-            return yield this.program.instruction.initializeUserOrders(userOrdersAccountNonce, {
-                accounts: {
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-                    systemProgram: anchor.web3.SystemProgram.programId,
-                    userOrders: userOrdersAccountPublicKey,
-                    state: yield this.getStatePublicKey(),
-                },
-            });
-        });
-    }
-    /**
-     * Get the address for the Clearing House User's account. NOT the user's wallet address.
-     * @returns
-     */
-    getUserAccountPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userAccountPublicKey) {
-                return this.userAccountPublicKey;
-            }
-            this.userAccountPublicKey = yield (0, addresses_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey);
-            return this.userAccountPublicKey;
-        });
-    }
-    getUserAccount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userAccount) {
-                return this.userAccount;
-            }
-            this.userAccount = (yield this.program.account.user.fetch(yield this.getUserAccountPublicKey()));
-            return this.userAccount;
-        });
-    }
-    /**
-     * Get the address for the Clearing House User Order's account. NOT the user's wallet address.
-     * @returns
-     */
-    getUserOrdersAccountPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userOrdersAccountPublicKey) {
-                return this.userOrdersAccountPublicKey;
-            }
-            this.userOrdersAccountPublicKey = yield (0, addresses_1.getUserOrdersAccountPublicKey)(this.program.programId, yield this.getUserAccountPublicKey());
-            return this.userOrdersAccountPublicKey;
-        });
+        if (this.isSubscribed) {
+            await Promise.all(this.unsubscribeUsers());
+        }
+        this.users.clear();
+        this.createUsers(userIds, this.userAccountSubscriptionConfig);
+        if (this.isSubscribed) {
+            await Promise.all(this.subscribeUsers());
+        }
+        this.activeUserId = activeUserId;
     }
-    userOrdersAccountExists() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userOrdersExist) {
-                return this.userOrdersExist;
-            }
-            const userOrdersAccountRPCResponse = yield this.connection.getParsedAccountInfo(yield this.getUserOrdersAccountPublicKey());
-            this.userOrdersExist = userOrdersAccountRPCResponse.value !== null;
-            return this.userOrdersExist;
-        });
+    async switchActiveUser(userId) {
+        this.activeUserId = userId;
     }
-    depositCollateral(amount, collateralAccountPublicKey, userPositionsAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const depositCollateralIx = yield this.getDepositCollateralInstruction(amount, collateralAccountPublicKey, userPositionsAccountPublicKey);
-            const tx = new web3_js_1.Transaction().add(depositCollateralIx);
-            return yield this.txSender.send(tx);
-        });
+    async addUser(userId) {
+        if (this.users.has(userId)) {
+            return;
+        }
+        const user = this.createUser(userId, this.userAccountSubscriptionConfig);
+        await user.subscribe();
+        this.users.set(userId, user);
+    }
+    async initializeUserAccount(userId = 0, name = userName_1.DEFAULT_USER_NAME) {
+        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
+        const tx = new web3_js_1.Transaction().add(initializeUserAccountIx);
+        const { txSig } = await this.txSender.send(tx, [], this.opts);
+        return [txSig, userAccountPublicKey];
+    }
+    async getInitializeUserInstructions(userId = 0, name = userName_1.DEFAULT_USER_NAME) {
+        const userAccountPublicKey = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId);
+        const nameBuffer = (0, userName_1.encodeName)(name);
+        const initializeUserAccountIx = await this.program.instruction.initializeUser(userId, nameBuffer, {
+            accounts: {
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+                payer: this.wallet.publicKey,
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                state: await this.getStatePublicKey(),
+            },
+        });
+        return [userAccountPublicKey, initializeUserAccountIx];
+    }
+    getUser(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 ${userId}`);
+        }
+        return this.users.get(userId);
     }
-    getDepositCollateralInstruction(amount, collateralAccountPublicKey, userPositionsAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            if (!userPositionsAccountPublicKey) {
-                userPositionsAccountPublicKey = (yield this.getUserAccount()).positions;
-            }
-            const state = this.getStateAccount();
-            return yield this.program.instruction.depositCollateral(amount, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    collateralVault: state.collateralVault,
-                    userCollateralAccount: collateralAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                    markets: state.markets,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    depositHistory: state.depositHistory,
-                    userPositions: userPositionsAccountPublicKey,
-                },
-            });
-        });
+    getUsers() {
+        return [...this.users.values()];
     }
-    /**
-     * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param amount
-     * @param collateralAccountPublicKey
-     * @returns
-     */
-    initializeUserAccountAndDepositCollateral(amount, collateralAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [userPositionsAccount, userAccountPublicKey, initializeUserAccountIx, initializeUserOrdersAccountIx,] = yield this.getInitializeUserInstructions();
-            const depositCollateralIx = yield this.getDepositCollateralInstruction(amount, collateralAccountPublicKey, userPositionsAccount.publicKey);
-            const tx = new web3_js_1.Transaction()
-                .add(initializeUserAccountIx)
-                .add(initializeUserOrdersAccountIx)
-                .add(depositCollateralIx);
-            const txSig = yield this.txSender.send(tx, [userPositionsAccount]);
-            return [txSig, userAccountPublicKey];
-        });
+    async getUserAccountPublicKey() {
+        return this.getUser().userAccountPublicKey;
     }
-    initializeUserAccountForDevnet(mockUSDCFaucet, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = yield mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
-            const [userPositionsAccount, userAccountPublicKey, initializeUserAccountIx, initializeUserOrdersAccountIx,] = yield this.getInitializeUserInstructions();
-            const depositCollateralIx = yield this.getDepositCollateralInstruction(amount, associateTokenPublicKey, userPositionsAccount.publicKey);
-            const tx = new web3_js_1.Transaction()
-                .add(createAssociatedAccountIx)
-                .add(mintToIx)
-                .add(initializeUserAccountIx)
-                .add(initializeUserOrdersAccountIx)
-                .add(depositCollateralIx);
-            const txSig = yield this.program.provider.sendAndConfirm(tx, [
-                userPositionsAccount,
-            ]);
-            return [txSig, userAccountPublicKey];
-        });
+    getUserAccount(userId) {
+        return this.getUser(userId).getUserAccount();
     }
-    withdrawCollateral(amount, collateralAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.txSender.send((0, utils_1.wrapInTx)(yield this.getWithdrawCollateralIx(amount, collateralAccountPublicKey)), [], this.opts);
-        });
+    getUserAccountAndSlot(userId) {
+        return this.getUser(userId).getUserAccountAndSlot();
     }
-    getWithdrawCollateralIx(amount, collateralAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const user = yield this.program.account.user.fetch(userAccountPublicKey);
-            const state = this.getStateAccount();
-            return yield this.program.instruction.withdrawCollateral(amount, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    collateralVault: state.collateralVault,
-                    collateralVaultAuthority: state.collateralVaultAuthority,
-                    insuranceVault: state.insuranceVault,
-                    insuranceVaultAuthority: state.insuranceVaultAuthority,
-                    userCollateralAccount: collateralAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                    markets: state.markets,
-                    userPositions: user.positions,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    depositHistory: state.depositHistory,
-                },
-            });
-        });
+    getUserBankBalance(bankIndex) {
+        const bankIndexBN = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
+        return this.getUserAccount().bankBalances.find((bankBalance) => bankBalance.bankIndex.eq(bankIndexBN));
     }
-    openPosition(direction, amount, marketIndex, limitPrice, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getOpenPositionIx(direction, amount, marketIndex, limitPrice, discountToken, referrer)), [], this.opts);
-        });
+    getQuoteAssetTokenAmount() {
+        const bank = this.getBankAccount(numericConstants_1.QUOTE_ASSET_BANK_INDEX);
+        const userBankBalance = this.getUserBankBalance(numericConstants_1.QUOTE_ASSET_BANK_INDEX);
+        return (0, bankBalance_1.getTokenAmount)(userBankBalance.balance, bank, userBankBalance.balanceType);
     }
-    getOpenPositionIx(direction, amount, marketIndex, limitPrice, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            if (limitPrice == undefined) {
-                limitPrice = new anchor_1.BN(0); // no limit
-            }
-            const optionalAccounts = {
-                discountToken: false,
-                referrer: false,
-            };
-            const remainingAccounts = [];
-            if (discountToken) {
-                optionalAccounts.discountToken = true;
-                remainingAccounts.push({
-                    pubkey: discountToken,
-                    isWritable: false,
+    getRemainingAccounts(params) {
+        const userAccountAndSlot = this.getUserAccountAndSlot();
+        if (!userAccountAndSlot) {
+            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
+        }
+        const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
+            // if cache has more recent slot than user positions account slot, add market to remaining accounts
+            // otherwise remove from slot
+            if (slot > lastUserPositionsSlot) {
+                const marketAccount = this.getMarketAccount(marketIndexNum);
+                marketAccountMap.set(marketIndexNum, {
+                    pubkey: marketAccount.pubkey,
                     isSigner: false,
+                    isWritable: false,
                 });
-            }
-            if (referrer) {
-                optionalAccounts.referrer = true;
-                remainingAccounts.push({
-                    pubkey: referrer,
-                    isWritable: true,
+                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                    pubkey: marketAccount.amm.oracle,
                     isSigner: false,
+                    isWritable: false,
                 });
             }
-            const priceOracle = this.getMarketsAccount().markets[marketIndex.toNumber()].amm.oracle;
-            const state = this.getStateAccount();
-            return yield this.program.instruction.openPosition(direction, amount, marketIndex, limitPrice, optionalAccounts, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userPositions: userAccount.positions,
-                    tradeHistory: state.tradeHistory,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    oracle: priceOracle,
-                },
-                remainingAccounts: remainingAccounts,
-            });
-        });
-    }
-    initializeUserOrdersThenPlaceOrder(orderParams, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instructions = [];
-            const userOrdersAccountExists = yield this.userOrdersAccountExists();
-            if (!userOrdersAccountExists) {
-                instructions.push(yield this.getInitializeUserOrdersInstruction());
+            else {
+                this.marketLastSlotCache.delete(marketIndexNum);
             }
-            instructions.push(yield this.getPlaceOrderIx(orderParams, discountToken, referrer));
-            const tx = new web3_js_1.Transaction();
-            for (const instruction of instructions) {
-                tx.add(instruction);
-            }
-            return yield this.txSender.send(tx, [], this.opts);
-        });
-    }
-    placeOrder(orderParams, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getPlaceOrderIx(orderParams, discountToken, referrer)), [], this.opts);
-        });
-    }
-    getPlaceOrderIx(orderParams, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const priceOracle = this.getMarketsAccount().markets[orderParams.marketIndex.toNumber()].amm
-                .oracle;
-            const remainingAccounts = [];
-            if (orderParams.optionalAccounts.discountToken) {
-                if (!discountToken) {
-                    throw Error('Optional accounts specified discount token but no discount token present');
-                }
-                remainingAccounts.push({
-                    pubkey: discountToken,
-                    isWritable: false,
+        }
+        for (const position of userAccount.positions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                const marketIndexNum = position.marketIndex.toNumber();
+                const marketAccount = this.getMarketAccount(marketIndexNum);
+                marketAccountMap.set(marketIndexNum, {
+                    pubkey: marketAccount.pubkey,
                     isSigner: false,
+                    // isWritable: false, // TODO
+                    isWritable: true,
                 });
-            }
-            if (orderParams.optionalAccounts.referrer) {
-                if (!referrer) {
-                    throw Error('Optional accounts specified referrer but no referrer present');
-                }
-                remainingAccounts.push({
-                    pubkey: referrer,
-                    isWritable: false,
+                oracleAccountMap.set(marketAccount.pubkey.toString(), {
+                    pubkey: marketAccount.amm.oracle,
                     isSigner: false,
-                });
-            }
-            if (!orderParams.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-                remainingAccounts.push({
-                    pubkey: priceOracle,
                     isWritable: false,
-                    isSigner: false,
                 });
             }
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            return yield this.program.instruction.placeOrder(orderParams, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userOrders: yield this.getUserOrdersAccountPublicKey(),
-                    userPositions: userAccount.positions,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                },
-                remainingAccounts,
+        }
+        if (params.writableMarketIndex) {
+            const marketAccount = this.getMarketAccount(params.writableMarketIndex.toNumber());
+            marketAccountMap.set(params.writableMarketIndex.toNumber(), {
+                pubkey: marketAccount.pubkey,
+                isSigner: false,
+                isWritable: true,
             });
-        });
-    }
-    expireOrders(userAccountPublicKey, userOrdersAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getExpireOrdersIx(userAccountPublicKey, userOrdersAccountPublicKey)), [], this.opts);
-        });
-    }
-    getExpireOrdersIx(userAccountPublicKey, userOrdersAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fillerPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.program.account.user.fetch(userAccountPublicKey);
-            const orderState = this.getOrderStateAccount();
-            return yield this.program.instruction.expireOrders({
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    filler: fillerPublicKey,
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    userPositions: userAccount.positions,
-                    userOrders: userOrdersAccountPublicKey,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                },
+            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                pubkey: marketAccount.amm.oracle,
+                isSigner: false,
+                isWritable: false,
             });
-        });
-    }
-    cancelOrder(orderId, oracle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrderIx(orderId, oracle)), [], this.opts);
-        });
-    }
-    getCancelOrderIx(orderId, oracle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            const remainingAccounts = [];
-            if (oracle) {
-                remainingAccounts.push({
-                    pubkey: oracle,
-                    isWritable: false,
+        }
+        for (const userBankBalance of userAccount.bankBalances) {
+            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
+                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
+                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
+                    pubkey: bankAccount.pubkey,
                     isSigner: false,
-                });
-            }
-            return yield this.program.instruction.cancelOrder(orderId, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userOrders: yield this.getUserOrdersAccountPublicKey(),
-                    userPositions: userAccount.positions,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                },
-                remainingAccounts,
-            });
-        });
-    }
-    cancelOrderByUserId(userOrderId, oracle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrderByUserIdIx(userOrderId, oracle)), [], this.opts);
-        });
-    }
-    getCancelOrderByUserIdIx(userOrderId, oracle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            const remainingAccounts = [];
-            if (oracle) {
-                remainingAccounts.push({
-                    pubkey: oracle,
                     isWritable: false,
-                    isSigner: false,
                 });
+                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
             }
-            return yield this.program.instruction.cancelOrderByUserId(userOrderId, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userOrders: yield this.getUserOrdersAccountPublicKey(),
-                    userPositions: userAccount.positions,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                },
-                remainingAccounts,
+        }
+        if (params.writableBankIndex) {
+            const bankAccount = this.getBankAccount(params.writableBankIndex);
+            bankAccountMap.set(params.writableBankIndex.toNumber(), {
+                pubkey: bankAccount.pubkey,
+                isSigner: false,
+                isWritable: true,
             });
-        });
-    }
-    cancelAllOrders(oracles, bestEffort) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelAllOrdersIx(oracles, bestEffort)), [], this.opts);
-        });
-    }
-    getCancelAllOrdersIx(oracles, bestEffort) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            const remainingAccounts = [];
-            for (const oracle of oracles) {
-                remainingAccounts.push({
-                    pubkey: oracle,
-                    isWritable: false,
+            if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
+                oracleAccountMap.set(bankAccount.oracle.toString(), {
+                    pubkey: bankAccount.oracle,
                     isSigner: false,
+                    isWritable: false,
                 });
             }
-            return yield this.program.instruction.cancelAllOrders(bestEffort, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userOrders: yield this.getUserOrdersAccountPublicKey(),
-                    userPositions: userAccount.positions,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                },
-                remainingAccounts,
+        }
+        return [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
+    }
+    getOrder(orderId) {
+        var _a;
+        const orderIdBN = orderId instanceof anchor_1.BN ? orderId : new anchor_1.BN(orderId);
+        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.orderId.eq(orderIdBN));
+    }
+    getOrderByUserId(userOrderId) {
+        var _a;
+        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.find((order) => order.userOrderId === userOrderId);
+    }
+    async deposit(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly = false) {
+        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, collateralAccountPublicKey, userId, reduceOnly, true);
+        const tx = new web3_js_1.Transaction().add(depositCollateralIx);
+        const { txSig } = await this.txSender.send(tx);
+        return txSig;
+    }
+    async getDepositInstruction(amount, bankIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
+        const userAccountPublicKey = userId
+            ? await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, userId)
+            : await this.getUserAccountPublicKey();
+        let remainingAccounts = [];
+        if (userInitialized) {
+            remainingAccounts = this.getRemainingAccounts({
+                writableBankIndex: bankIndex,
             });
-        });
-    }
-    cancelOrdersByMarketAndSide(oracles, bestEffort, marketIndexOnly, directionOnly) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrdersByMarketAndSideIx(oracles, bestEffort, marketIndexOnly, directionOnly)), [], this.opts);
-        });
-    }
-    getCancelOrdersByMarketAndSideIx(oracles, bestEffort, marketIndexOnly, directionOnly) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            const remainingAccounts = [];
-            for (const oracle of oracles) {
-                remainingAccounts.push({
-                    pubkey: oracle,
-                    isWritable: false,
+        }
+        else {
+            remainingAccounts = [
+                {
+                    pubkey: this.getBankAccount(bankIndex).pubkey,
                     isSigner: false,
-                });
-            }
-            return yield this.program.instruction.cancelOrdersByMarketAndSide(bestEffort, marketIndexOnly, directionOnly, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userOrders: yield this.getUserOrdersAccountPublicKey(),
-                    userPositions: userAccount.positions,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
+                    isWritable: true,
                 },
-                remainingAccounts,
-            });
-        });
-    }
-    fillOrder(userAccountPublicKey, userOrdersAccountPublicKey, order) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getFillOrderIx(userAccountPublicKey, userOrdersAccountPublicKey, order)), [], this.opts);
+            ];
+        }
+        const bank = this.getBankAccount(bankIndex);
+        return await this.program.instruction.deposit(bankIndex, amount, reduceOnly, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                bankVault: bank.vault,
+                user: userAccountPublicKey,
+                userTokenAccount: userTokenAccount,
+                authority: this.wallet.publicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
         });
     }
-    getFillOrderIx(userAccountPublicKey, userOrdersAccountPublicKey, order) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fillerPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.program.account.user.fetch(userAccountPublicKey);
-            const marketIndex = order.marketIndex;
-            const oracle = this.getMarket(marketIndex).amm.oracle;
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            const remainingAccounts = [];
-            if (!order.referrer.equals(web3_js_1.PublicKey.default)) {
-                remainingAccounts.push({
-                    pubkey: order.referrer,
+    /**
+     * Creates the Clearing House User account for a user, and deposits some initial collateral
+     * @param userId
+     * @param name
+     * @param amount
+     * @param userTokenAccount
+     * @param fromUserId
+     * @returns
+     */
+    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, bankIndex = new anchor_1.BN(0), userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId) {
+        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
+        const depositCollateralIx = fromUserId != null
+            ? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
+            : await this.getDepositInstruction(amount, bankIndex, userTokenAccount, userId, false, false);
+        const tx = new web3_js_1.Transaction()
+            .add(initializeUserAccountIx)
+            .add(depositCollateralIx);
+        const { txSig } = await this.txSender.send(tx, []);
+        return [txSig, userAccountPublicKey];
+    }
+    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, mockUSDCFaucet, amount) {
+        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
+        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
+        const depositCollateralIx = await this.getDepositInstruction(amount, new anchor_1.BN(0), associateTokenPublicKey, userId, false, false);
+        const tx = new web3_js_1.Transaction()
+            .add(createAssociatedAccountIx)
+            .add(mintToIx)
+            .add(initializeUserAccountIx)
+            .add(depositCollateralIx);
+        const txSig = await this.program.provider.sendAndConfirm(tx, []);
+        return [txSig, userAccountPublicKey];
+    }
+    async withdraw(amount, bankIndex, userTokenAccount, reduceOnly = false) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly)), [], this.opts);
+        return txSig;
+    }
+    async getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly = false) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        const bank = this.getBankAccount(bankIndex);
+        return await this.program.instruction.withdraw(bankIndex, amount, reduceOnly, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                bankVault: bank.vault,
+                bankVaultAuthority: bank.vaultAuthority,
+                user: userAccountPublicKey,
+                userTokenAccount: userTokenAccount,
+                authority: this.wallet.publicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async transferDeposit(amount, bankIndex, fromUserId, toUserId) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTransferDepositIx(amount, bankIndex, fromUserId, toUserId)), [], this.opts);
+        return txSig;
+    }
+    async getTransferDepositIx(amount, bankIndex, fromUserId, toUserId) {
+        const fromUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, fromUserId);
+        const toUser = await (0, pda_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey, toUserId);
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        return await this.program.instruction.transferDeposit(bankIndex, amount, {
+            accounts: {
+                authority: this.wallet.publicKey,
+                fromUser,
+                toUser,
+                state: await this.getStatePublicKey(),
+            },
+            remainingAccounts,
+        });
+    }
+    async updateBankCumulativeInterest(bankIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.updateBankCumulativeInterestIx(bankIndex)), [], this.opts);
+        return txSig;
+    }
+    async updateBankCumulativeInterestIx(bankIndex) {
+        const bank = this.getBankAccount(bankIndex);
+        return await this.program.instruction.updateBankCumulativeInterest({
+            accounts: {
+                bank: bank.pubkey,
+            },
+        });
+    }
+    async openPosition(direction, amount, marketIndex, limitPrice) {
+        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, direction, numericConstants_1.ZERO, amount, false, limitPrice));
+    }
+    async placeOrder(orderParams) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams)), [], this.opts);
+        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+        return txSig;
+    }
+    async getPlaceOrderIx(orderParams) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
+            .oracle;
+        const remainingAccounts = this.getRemainingAccounts({
+            writableMarketIndex: orderParams.marketIndex,
+        });
+        return await this.program.instruction.placeOrder(orderParams, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+                oracle: priceOracle,
+            },
+            remainingAccounts,
+        });
+    }
+    async expireOrders(userAccountPublicKey) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getExpireOrdersIx(userAccountPublicKey)), [], this.opts);
+        return txSig;
+    }
+    async getExpireOrdersIx(userAccountPublicKey) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        return await this.program.instruction.expireOrders({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+        });
+    }
+    async updateAMMs(marketIndexes) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateAMMsIx(marketIndexes)), [], this.opts);
+        return txSig;
+    }
+    async getUpdateAMMsIx(marketIndexes) {
+        for (let i = marketIndexes.length; i < 5; i++) {
+            marketIndexes.push(new anchor_1.BN(100));
+        }
+        const marketAccountInfos = [];
+        const oracleAccountInfos = [];
+        for (const marketIndex of marketIndexes) {
+            if (!marketIndex.eq(new anchor_1.BN(100))) {
+                const market = this.getMarketAccount(marketIndex);
+                marketAccountInfos.push({
+                    pubkey: market.pubkey,
                     isWritable: true,
                     isSigner: false,
                 });
+                oracleAccountInfos.push({
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
             }
-            const orderId = order.orderId;
-            return yield this.program.instruction.fillOrder(orderId, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    filler: fillerPublicKey,
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userPositions: userAccount.positions,
-                    userOrders: userOrdersAccountPublicKey,
-                    tradeHistory: state.tradeHistory,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                    extendedCurveHistory: state.extendedCurveHistory,
-                    oracle: oracle,
-                },
-                remainingAccounts,
+        }
+        const remainingAccounts = oracleAccountInfos.concat(marketAccountInfos);
+        return await this.program.instruction.updateAmms(marketIndexes, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
+    async cancelOrder(orderId) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrderIx(orderId)), [], this.opts);
+        return txSig;
+    }
+    async getCancelOrderIx(orderId) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const order = this.getOrder(orderId);
+        const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+        const remainingAccounts = this.getRemainingAccounts({});
+        return await this.program.instruction.cancelOrder(orderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+                oracle,
+            },
+            remainingAccounts,
+        });
+    }
+    async cancelOrderByUserId(userOrderId) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrderByUserIdIx(userOrderId)), [], this.opts);
+        return txSig;
+    }
+    async getCancelOrderByUserIdIx(userOrderId) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const order = this.getOrderByUserId(userOrderId);
+        const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+        const remainingAccounts = this.getRemainingAccounts({});
+        return await this.program.instruction.cancelOrderByUserId(userOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+                oracle,
+            },
+            remainingAccounts,
+        });
+    }
+    async cancelAllOrders(bestEffort) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelAllOrdersIx(bestEffort)), [], this.opts);
+        return txSig;
+    }
+    async getCancelAllOrdersIx(bestEffort) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({});
+        for (const order of this.getUserAccount().orders) {
+            const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+            remainingAccounts.push({
+                pubkey: oracle,
+                isWritable: false,
+                isSigner: false,
             });
-        });
-    }
-    initializeUserOrdersThenPlaceAndFillOrder(orderParams, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instructions = [];
-            const userOrdersAccountExists = yield this.userOrdersAccountExists();
-            if (!userOrdersAccountExists) {
-                instructions.push(yield this.getInitializeUserOrdersInstruction());
-            }
-            instructions.push(yield this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer));
-            const tx = new web3_js_1.Transaction();
-            for (const instruction of instructions) {
-                tx.add(instruction);
-            }
-            return yield this.txSender.send(tx, [], this.opts);
-        });
-    }
-    placeAndFillOrder(orderParams, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer)), [], this.opts);
-        });
-    }
-    getPlaceAndFillOrderIx(orderParams, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const priceOracle = this.getMarketsAccount().markets[orderParams.marketIndex.toNumber()].amm
-                .oracle;
-            const remainingAccounts = [];
-            if (orderParams.optionalAccounts.discountToken) {
-                if (!discountToken) {
-                    throw Error('Optional accounts specified discount token but no discount token present');
-                }
-                remainingAccounts.push({
-                    pubkey: discountToken,
+        }
+        return await this.program.instruction.cancelAllOrders(bestEffort, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
+    async cancelOrdersByMarketAndSide(bestEffort, marketIndexOnly, directionOnly) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrdersByMarketAndSideIx(bestEffort, marketIndexOnly, directionOnly)), [], this.opts);
+        return txSig;
+    }
+    async getCancelOrdersByMarketAndSideIx(bestEffort, marketIndexOnly, directionOnly) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({});
+        for (const order of this.getUserAccount().orders) {
+            const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+            remainingAccounts.push({
+                pubkey: oracle,
+                isWritable: false,
+                isSigner: false,
+            });
+        }
+        return await this.program.instruction.cancelOrdersByMarketAndSide(bestEffort, marketIndexOnly, directionOnly, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
+    async fillOrder(userAccountPublicKey, user, order, makerInfo) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)), [], this.opts);
+        return txSig;
+    }
+    async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const marketIndex = order.marketIndex;
+        const marketAccount = this.getMarketAccount(marketIndex);
+        const oracle = marketAccount.amm.oracle;
+        const bankAccountInfos = [
+            {
+                pubkey: this.getQuoteAssetBankAccount().pubkey,
+                isSigner: false,
+                isWritable: true,
+            },
+        ];
+        const marketAccountInfos = [
+            {
+                pubkey: marketAccount.pubkey,
+                isWritable: true,
+                isSigner: false,
+            },
+        ];
+        const oracleAccountInfos = [
+            {
+                pubkey: marketAccount.amm.oracle,
+                isWritable: false,
+                isSigner: false,
+            },
+        ];
+        for (const position of userAccount.positions) {
+            if (!(0, position_1.positionIsAvailable)(position) &&
+                !position.marketIndex.eq(order.marketIndex)) {
+                const market = this.getMarketAccount(position.marketIndex);
+                marketAccountInfos.push({
+                    pubkey: market.pubkey,
                     isWritable: false,
                     isSigner: false,
                 });
-            }
-            if (orderParams.optionalAccounts.referrer) {
-                if (!referrer) {
-                    throw Error('Optional accounts specified referrer but no referrer present');
-                }
-                remainingAccounts.push({
-                    pubkey: referrer,
-                    isWritable: true,
+                oracleAccountInfos.push({
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
                     isSigner: false,
                 });
             }
-            const state = this.getStateAccount();
-            const orderState = this.getOrderStateAccount();
-            return yield this.program.instruction.placeAndFillOrder(orderParams, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userOrders: yield this.getUserOrdersAccountPublicKey(),
-                    userPositions: userAccount.positions,
-                    tradeHistory: state.tradeHistory,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    orderState: yield this.getOrderStatePublicKey(),
-                    orderHistory: orderState.orderHistory,
-                    extendedCurveHistory: state.extendedCurveHistory,
-                    oracle: priceOracle,
-                },
-                remainingAccounts,
+        }
+        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
+        if (makerInfo) {
+            remainingAccounts.push({
+                pubkey: makerInfo.maker,
+                isWritable: true,
+                isSigner: false,
             });
+        }
+        const orderId = order.orderId;
+        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+        return await this.program.instruction.fillOrder(orderId, makerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+                oracle: oracle,
+            },
+            remainingAccounts,
+        });
+    }
+    async placeAndTake(orderParams, makerInfo) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakeIx(orderParams, makerInfo)), [], this.opts);
+        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+        return txSig;
+    }
+    async getPlaceAndTakeIx(orderParams, makerInfo) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
+            .oracle;
+        const remainingAccounts = this.getRemainingAccounts({
+            writableMarketIndex: orderParams.marketIndex,
+            writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
+        });
+        let makerOrderId = null;
+        if (makerInfo) {
+            makerOrderId = makerInfo.order.orderId;
+            remainingAccounts.push({
+                pubkey: makerInfo.maker,
+                isSigner: false,
+                isWritable: true,
+            });
+        }
+        return await this.program.instruction.placeAndTake(orderParams, makerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+                oracle: priceOracle,
+            },
+            remainingAccounts,
         });
     }
     /**
      * 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
-     * @param discountToken
-     * @param referrer
      * @returns
      */
-    closePosition(marketIndex, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getClosePositionIx(marketIndex, discountToken, referrer)), [], this.opts);
-        });
+    async closePosition(marketIndex) {
+        const userPosition = this.getUser().getUserPosition(marketIndex);
+        if (!userPosition) {
+            throw Error(`No position in market ${marketIndex.toString()}`);
+        }
+        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, (0, position_1.findDirectionToClose)(userPosition), numericConstants_1.ZERO, userPosition.baseAssetAmount, true, undefined));
     }
-    getClosePositionIx(marketIndex, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccount = yield this.getUserAccount();
-            const priceOracle = this.getMarketsAccount().markets[marketIndex.toNumber()].amm.oracle;
-            const optionalAccounts = {
-                discountToken: false,
-                referrer: false,
-            };
-            const remainingAccounts = [];
-            if (discountToken) {
-                optionalAccounts.discountToken = true;
-                remainingAccounts.push({
-                    pubkey: discountToken,
+    async settlePNLs(users, marketIndex) {
+        const ixs = [];
+        for (const { settleeUserAccountPublicKey, settleeUserAccount } of users) {
+            ixs.push(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex));
+        }
+        const tx = new web3_js_1.Transaction().add(...ixs);
+        const { txSig } = await this.txSender.send(tx, [], this.opts);
+        return txSig;
+    }
+    async settlePNL(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
+        const marketAccountMap = new Map();
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        for (const position of settleeUserAccount.positions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                const market = this.getMarketAccount(position.marketIndex);
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: true,
+                    isSigner: false,
+                });
+                oracleAccountMap.set(market.amm.oracle.toString(), {
+                    pubkey: market.amm.oracle,
                     isWritable: false,
                     isSigner: false,
                 });
             }
-            if (referrer) {
-                optionalAccounts.referrer = true;
-                remainingAccounts.push({
-                    pubkey: referrer,
-                    isWritable: true,
+        }
+        for (const userBankBalance of settleeUserAccount.bankBalances) {
+            if (!userBankBalance.balance.eq(numericConstants_1.QUOTE_ASSET_BANK_INDEX)) {
+                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
+                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
+                    pubkey: bankAccount.pubkey,
                     isSigner: false,
+                    isWritable: false,
                 });
-            }
-            const state = this.getStateAccount();
-            return yield this.program.instruction.closePosition(marketIndex, optionalAccounts, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    markets: state.markets,
-                    userPositions: userAccount.positions,
-                    tradeHistory: state.tradeHistory,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                    fundingRateHistory: state.fundingRateHistory,
-                    oracle: priceOracle,
-                },
-                remainingAccounts: remainingAccounts,
-            });
-        });
-    }
-    closeAllPositions(userPositionsAccount, discountToken, referrer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [];
-            for (const userPosition of userPositionsAccount.positions) {
-                if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-                    continue;
-                }
-                ixs.push(yield this.getClosePositionIx(userPosition.marketIndex, discountToken, referrer));
-            }
-            const tx = new web3_js_1.Transaction().add(...ixs);
-            return this.txSender.send(tx, [], this.opts);
-        });
-    }
-    liquidate(liquidateeUserAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.txSender.send((0, utils_1.wrapInTx)(yield this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);
-        });
-    }
-    getLiquidateIx(liquidateeUserAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const liquidateeUserAccount = yield this.program.account.user.fetch(liquidateeUserAccountPublicKey);
-            const liquidateePositions = yield this.program.account.userPositions.fetch(liquidateeUserAccount.positions);
-            const markets = this.getMarketsAccount();
-            const remainingAccounts = [];
-            for (const position of liquidateePositions.positions) {
-                if (!position.baseAssetAmount.eq(new anchor_1.BN(0))) {
-                    const market = markets.markets[position.marketIndex.toNumber()];
-                    remainingAccounts.push({
-                        pubkey: market.amm.oracle,
-                        isWritable: false,
+                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
                         isSigner: false,
+                        isWritable: false,
                     });
                 }
             }
-            const state = this.getStateAccount();
-            return yield this.program.instruction.liquidate({
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    authority: this.wallet.publicKey,
-                    user: liquidateeUserAccountPublicKey,
-                    liquidator: userAccountPublicKey,
-                    collateralVault: state.collateralVault,
-                    collateralVaultAuthority: state.collateralVaultAuthority,
-                    insuranceVault: state.insuranceVault,
-                    insuranceVaultAuthority: state.insuranceVaultAuthority,
-                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                    markets: state.markets,
-                    userPositions: liquidateeUserAccount.positions,
-                    tradeHistory: state.tradeHistory,
-                    liquidationHistory: state.liquidationHistory,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                },
-                remainingAccounts: remainingAccounts,
-            });
-        });
-    }
-    updateFundingRate(oracle, marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.txSender.send((0, utils_1.wrapInTx)(yield this.getUpdateFundingRateIx(oracle, marketIndex)), [], this.opts);
-        });
-    }
-    getUpdateFundingRateIx(oracle, marketIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            return yield this.program.instruction.updateFundingRate(marketIndex, {
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                    oracle: oracle,
-                    fundingRateHistory: state.fundingRateHistory,
-                },
-            });
-        });
-    }
-    settleFundingPayment(userAccount, userPositionsAccount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.txSender.send((0, utils_1.wrapInTx)(yield this.getSettleFundingPaymentIx(userAccount, userPositionsAccount)), [], this.opts);
-        });
-    }
-    getSettleFundingPaymentIx(userAccount, userPositionsAccount) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const state = this.getStateAccount();
-            return yield this.program.instruction.settleFundingPayment({
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    markets: state.markets,
-                    user: userAccount,
-                    userPositions: userPositionsAccount,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                },
-            });
+        }
+        const marketAccount = this.getMarketAccount(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,
+        });
+        bankAccountMap.set(numericConstants_1.QUOTE_ASSET_BANK_INDEX.toNumber(), {
+            pubkey: this.getBankAccount(numericConstants_1.QUOTE_ASSET_BANK_INDEX).pubkey,
+            isSigner: false,
+            isWritable: true,
+        });
+        const remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
+        return await this.program.instruction.settlePnl(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: settleeUserAccountPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async liquidate(liquidateeUserAccountPublicKey) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);
+        return txSig;
+    }
+    async getLiquidateIx(liquidateeUserAccountPublicKey) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const liquidateeUserAccount = (await this.program.account.user.fetch(liquidateeUserAccountPublicKey));
+        const bankAccountInfos = [
+            {
+                pubkey: this.getQuoteAssetBankAccount().pubkey,
+                isSigner: false,
+                isWritable: true,
+            },
+        ];
+        const marketAccountInfos = [];
+        const oracleAccountInfos = [];
+        for (const position of liquidateeUserAccount.positions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                const market = this.getMarketAccount(position.marketIndex);
+                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
+                marketAccountInfos.push({
+                    pubkey: marketPublicKey,
+                    isWritable: true,
+                    isSigner: false,
+                });
+                oracleAccountInfos.push({
+                    pubkey: market.amm.oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
+        const state = this.getStateAccount();
+        const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
+        return await this.program.instruction.liquidate({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: liquidateeUserAccountPublicKey,
+                liquidator: userAccountPublicKey,
+                bankVault: quoteAssetBankAccount.vault,
+                bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
+                insuranceVault: state.insuranceVault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async updateFundingRate(oracle, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateFundingRateIx(oracle, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getUpdateFundingRateIx(oracle, marketIndex) {
+        return await this.program.instruction.updateFundingRate(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+                oracle: oracle,
+            },
+        });
+    }
+    async settleFundingPayment(userAccount) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleFundingPaymentIx(userAccount)), [], this.opts);
+        return txSig;
+    }
+    async getSettleFundingPaymentIx(userAccount) {
+        const user = (await this.program.account.user.fetch(userAccount));
+        const userPositions = user.positions;
+        const remainingAccounts = [];
+        for (const position of userPositions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
+                remainingAccounts.push({
+                    pubkey: marketPublicKey,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
+        }
+        return await this.program.instruction.settleFundingPayment({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccount,
+            },
+            remainingAccounts,
         });
     }
     triggerEvent(eventName, data) {
         this.eventEmitter.emit(eventName, data);
     }
-    settlePositionAndClaimCollateral(collateralAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const settlePositionIx = yield this.getSettlePositionIx();
-            const claimCollateralIx = yield this.getClaimCollateralIx(collateralAccountPublicKey);
-            const tx = new web3_js_1.Transaction().add(settlePositionIx).add(claimCollateralIx);
-            return this.txSender.send(tx, [], this.opts);
-        });
-    }
-    getSettlePositionIx() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const user = yield this.program.account.user.fetch(userAccountPublicKey);
-            const state = this.getStateAccount();
-            const settlementState = yield (0, addresses_1.getSettlementStatePublicKey)(this.program.programId);
-            return yield this.program.instruction.settlePosition({
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    markets: state.markets,
-                    authority: this.wallet.publicKey,
-                    userPositions: user.positions,
-                    settlementState,
-                    fundingPaymentHistory: state.fundingPaymentHistory,
-                },
-            });
-        });
-    }
-    getClaimCollateralIx(collateralAccountPublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const state = this.getStateAccount();
-            const settlementState = yield (0, addresses_1.getSettlementStatePublicKey)(this.program.programId);
-            return yield this.program.instruction.claimCollateral({
-                accounts: {
-                    state: yield this.getStatePublicKey(),
-                    user: userAccountPublicKey,
-                    collateralVault: state.collateralVault,
-                    collateralVaultAuthority: state.collateralVaultAuthority,
-                    userCollateralAccount: collateralAccountPublicKey,
-                    authority: this.wallet.publicKey,
-                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                    settlementState,
-                },
-            });
-        });
-    }
-    getTotalSettlementSize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accountLoader = new bulkAccountLoader_1.BulkAccountLoader(this.connection, 'processed', 50000);
-            const clearingHouse = (0, clearingHouse_1.getClearingHouse)((0, clearingHouse_1.getPollingClearingHouseConfig)(this.connection, this.wallet, this.program.programId, accountLoader));
-            console.log('loading all users');
-            const programUserAccounts = (yield this.program.account.user.all());
-            const userArray = [];
-            for (const programUserAccount of programUserAccounts) {
-                const user = (0, clearingHouseUser_1.getClearingHouseUser)((0, clearingHouseUser_1.getPollingClearingHouseUserConfig)(clearingHouse, programUserAccount.account.authority, accountLoader));
-                userArray.push(user);
-            }
-            console.log('subscribing all users');
-            yield (0, bulkUserSubscription_1.bulkPollingUserSubscribe)(userArray, accountLoader);
-            console.log('calculating settlement size');
-            const settlementSize = userArray.reduce((collateralToBeSettled, user) => {
-                return collateralToBeSettled.add(user.getUserAccount().forgoPositionSettlement === 0
-                    ? user.getSettledPositionValue()
-                    : numericConstants_1.ZERO);
-            }, numericConstants_1.ZERO);
-            for (const user of userArray) {
-                yield user.unsubscribe();
-            }
-            return settlementSize;
-        });
-    }
-    updateUserForgoSettlement() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.program.rpc.updateUserForgoSettlement({
-                accounts: {
-                    authority: this.wallet.publicKey,
-                    user: yield this.getUserAccountPublicKey(),
-                },
-            });
-        });
+    getOracleDataForMarket(marketIndex) {
+        const oracleKey = this.getMarketAccount(marketIndex).amm.oracle;
+        const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
     }
 }
 exports.ClearingHouse = ClearingHouse;