@drift-labs/sdk 0.2.0-temp.1 → 2.0.0

package/lib/clearingHouse.js

@@ -1,1154 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClearingHouse = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const spl_token_1 = require("@solana/spl-token");
-const types_1 = require("./types");
-const anchor = __importStar(require("@project-serum/anchor"));
-const clearing_house_json_1 = __importDefault(require("./idl/clearing_house.json"));
-const web3_js_1 = require("@solana/web3.js");
-const pda_1 = require("./addresses/pda");
-const utils_1 = require("./tx/utils");
-const numericConstants_1 = require("./constants/numericConstants");
-const position_1 = require("./math/position");
-const bankBalance_1 = require("./math/bankBalance");
-const 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 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.
- */
-class ClearingHouse {
-    constructor(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);
-        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 = 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;
-    }
-    set isSubscribed(val) {
-        this._isSubscribed = val;
-    }
-    createUsers(userIds, accountSubscriptionConfig) {
-        for (const userId of userIds) {
-            const user = this.createUser(userId, accountSubscriptionConfig);
-            this.users.set(userId, user);
-        }
-    }
-    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,
-        });
-    }
-    async subscribe() {
-        const subscribePromises = this.subscribeUsers().concat(this.accountSubscriber.subscribe());
-        this.isSubscribed = (await Promise.all(subscribePromises)).reduce((success, prevSuccess) => success && prevSuccess);
-        return this.isSubscribed;
-    }
-    subscribeUsers() {
-        return [...this.users.values()].map((user) => user.subscribe());
-    }
-    /**
-     *	Forces the accountSubscriber to fetch account updates from rpc
-     */
-    async fetchAccounts() {
-        await Promise.all([...this.users.values()]
-            .map((user) => user.fetchAccounts())
-            .concat(this.accountSubscriber.fetch()));
-    }
-    async unsubscribe() {
-        const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
-        await Promise.all(unsubscribePromises);
-        this.isSubscribed = false;
-    }
-    unsubscribeUsers() {
-        return [...this.users.values()].map((user) => user.unsubscribe());
-    }
-    async getStatePublicKey() {
-        if (this.statePublicKey) {
-            return this.statePublicKey;
-        }
-        this.statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-        return this.statePublicKey;
-    }
-    getStateAccount() {
-        return this.accountSubscriber.getStateAccountAndSlot().data;
-    }
-    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;
-    }
-    getMarketAccounts() {
-        return this.accountSubscriber
-            .getMarketAccountsAndSlots()
-            .map((value) => value.data);
-    }
-    getBankAccount(bankIndex) {
-        bankIndex = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
-        return this.accountSubscriber.getBankAccountAndSlot(bankIndex).data;
-    }
-    getQuoteAssetBankAccount() {
-        return this.accountSubscriber.getBankAccountAndSlot(numericConstants_1.QUOTE_ASSET_BANK_INDEX)
-            .data;
-    }
-    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
-     */
-    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
-        this.txSender.provider = newProvider;
-        this.wallet = newWallet;
-        this.provider = newProvider;
-        this.program = newProgram;
-        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;
-    }
-    async switchActiveUser(userId) {
-        this.activeUserId = userId;
-    }
-    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);
-    }
-    getUsers() {
-        return [...this.users.values()];
-    }
-    async getUserAccountPublicKey() {
-        return this.getUser().userAccountPublicKey;
-    }
-    getUserAccount(userId) {
-        return this.getUser(userId).getUserAccount();
-    }
-    getUserAccountAndSlot(userId) {
-        return this.getUser(userId).getUserAccountAndSlot();
-    }
-    getUserBankBalance(bankIndex) {
-        const bankIndexBN = bankIndex instanceof anchor_1.BN ? bankIndex : new anchor_1.BN(bankIndex);
-        return this.getUserAccount().bankBalances.find((bankBalance) => bankBalance.bankIndex.eq(bankIndexBN));
-    }
-    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);
-    }
-    getRemainingAccounts(params) {
-        const userAccountAndSlot = this.getUserAccountAndSlot();
-        if (!userAccountAndSlot) {
-            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
-        }
-        const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
-        const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
-        for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
-            // if cache has more recent slot than user positions account slot, add market to remaining accounts
-            // otherwise remove from slot
-            if (slot > lastUserPositionsSlot) {
-                const marketAccount = this.getMarketAccount(marketIndexNum);
-                marketAccountMap.set(marketIndexNum, {
-                    pubkey: marketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                    pubkey: marketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-            else {
-                this.marketLastSlotCache.delete(marketIndexNum);
-            }
-        }
-        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,
-                });
-                oracleAccountMap.set(marketAccount.pubkey.toString(), {
-                    pubkey: marketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-        }
-        if (params.writableMarketIndex) {
-            const marketAccount = this.getMarketAccount(params.writableMarketIndex.toNumber());
-            marketAccountMap.set(params.writableMarketIndex.toNumber(), {
-                pubkey: marketAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                pubkey: marketAccount.amm.oracle,
-                isSigner: false,
-                isWritable: false,
-            });
-        }
-        for (const userBankBalance of userAccount.bankBalances) {
-            if (!userBankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        if (params.writableBankIndex) {
-            const bankAccount = this.getBankAccount(params.writableBankIndex);
-            bankAccountMap.set(params.writableBankIndex.toNumber(), {
-                pubkey: bankAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-            if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                oracleAccountMap.set(bankAccount.oracle.toString(), {
-                    pubkey: bankAccount.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-        }
-        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,
-            });
-        }
-        else {
-            const bankAccount = this.getBankAccount(bankIndex);
-            if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                remainingAccounts.push({
-                    pubkey: bankAccount.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-            remainingAccounts.push({
-                pubkey: bankAccount.pubkey,
-                isSigner: false,
-                isWritable: true,
-            });
-        }
-        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,
-        });
-    }
-    /**
-     * 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, bankIndex, tokenFaucet, amount) {
-        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
-        const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
-        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, 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({
-            orderType: types_1.OrderType.MARKET,
-            marketIndex,
-            direction,
-            baseAssetAmount: amount,
-            price: 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;
-    }
-    getOrderParams(optionalOrderParams) {
-        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams);
-    }
-    async getPlaceOrderIx(orderParams) {
-        orderParams = this.getOrderParams(orderParams);
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        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,
-            },
-            remainingAccounts,
-        });
-    }
-    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 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 remainingAccounts = this.getRemainingAccounts({});
-        return await this.program.instruction.cancelOrder(orderId !== null && orderId !== void 0 ? orderId : null, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-            },
-            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 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 oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
-        marketAccountMap.set(marketIndex.toNumber(), {
-            pubkey: marketAccount.pubkey,
-            isWritable: true,
-            isSigner: false,
-        });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isWritable: false,
-            isSigner: false,
-        });
-        for (const bankBalance of userAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                !position.marketIndex.eq(order.marketIndex)) {
-                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,
-                });
-            }
-        }
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
-        ];
-        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,
-            },
-            remainingAccounts,
-        });
-    }
-    async triggerOrder(userAccountPublicKey, user, order) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getTriggerOrderIx(userAccountPublicKey, user, order)), [], this.opts);
-        return txSig;
-    }
-    async getTriggerOrderIx(userAccountPublicKey, userAccount, order) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
-        const marketIndex = order.marketIndex;
-        const marketAccount = this.getMarketAccount(marketIndex);
-        const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
-        marketAccountMap.set(marketIndex.toNumber(), {
-            pubkey: marketAccount.pubkey,
-            isWritable: true,
-            isSigner: false,
-        });
-        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-            pubkey: marketAccount.amm.oracle,
-            isWritable: false,
-            isSigner: false,
-        });
-        for (const bankBalance of userAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position) &&
-                !position.marketIndex.eq(order.marketIndex)) {
-                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,
-                });
-            }
-        }
-        const remainingAccounts = [
-            ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
-        ];
-        const orderId = order.orderId;
-        return await this.program.instruction.triggerOrder(orderId, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                filler: fillerPublicKey,
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-            },
-            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) {
-        orderParams = this.getOrderParams(orderParams);
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        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,
-            },
-            remainingAccounts,
-        });
-    }
-    async placeAndMake(orderParams, takerInfo) {
-        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakeIx(orderParams, takerInfo)), [], this.opts);
-        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
-        return txSig;
-    }
-    async getPlaceAndMakeIx(orderParams, takerInfo) {
-        orderParams = this.getOrderParams(orderParams);
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: orderParams.marketIndex,
-            writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
-        });
-        const takerOrderId = takerInfo.order.orderId;
-        remainingAccounts.push({
-            pubkey: takerInfo.taker,
-            isSigner: false,
-            isWritable: true,
-        });
-        return await this.program.instruction.placeAndMake(orderParams, takerOrderId, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                taker: takerInfo.taker,
-                authority: this.wallet.publicKey,
-            },
-            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
-     * @returns
-     */
-    async closePosition(marketIndex) {
-        const userPosition = this.getUser().getUserPosition(marketIndex);
-        if (!userPosition) {
-            throw Error(`No position in market ${marketIndex.toString()}`);
-        }
-        return await this.placeAndTake({
-            orderType: types_1.OrderType.MARKET,
-            marketIndex,
-            direction: (0, position_1.findDirectionToClose)(userPosition),
-            baseAssetAmount: userPosition.baseAssetAmount,
-            reduceOnly: true,
-        });
-    }
-    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,
-                });
-            }
-        }
-        for (const userBankBalance of settleeUserAccount.bankBalances) {
-            if (!userBankBalance.balance.eq(numericConstants_1.QUOTE_ASSET_BANK_INDEX)) {
-                const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-                bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!bankAccount.bankIndex.eq(numericConstants_1.ZERO)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        const marketAccount = this.getMarketAccount(marketIndex.toNumber());
-        marketAccountMap.set(marketIndex.toNumber(), {
-            pubkey: marketAccount.pubkey,
-            isSigner: false,
-            isWritable: true,
-        });
-        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 liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount)), [], this.opts);
-        return txSig;
-    }
-    async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            writableMarketIndex: marketIndex,
-            userAccount,
-        });
-        return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                authority: this.wallet.publicKey,
-                user: userAccountPublicKey,
-                liquidator: liquidatorPublicKey,
-            },
-            remainingAccounts: remainingAccounts,
-        });
-    }
-    async liquidateBorrow(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer)), [], this.opts);
-        return txSig;
-    }
-    async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
-            writableBankIndexes: [liabilityBankIndex, assetBankIndex],
-        });
-        return await this.program.instruction.liquidateBorrow(assetBankIndex, liabilityBankIndex, maxLiabilityTransfer, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                authority: this.wallet.publicKey,
-                user: userAccountPublicKey,
-                liquidator: liquidatorPublicKey,
-            },
-            remainingAccounts: remainingAccounts,
-        });
-    }
-    async liquidateBorrowForPerpPnl(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer)), [], this.opts);
-        return txSig;
-    }
-    async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
-            writableMarketIndex: perpMarketIndex,
-            writableBankIndexes: [liabilityBankIndex],
-        });
-        return await this.program.instruction.liquidateBorrowForPerpPnl(perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                authority: this.wallet.publicKey,
-                user: userAccountPublicKey,
-                liquidator: liquidatorPublicKey,
-            },
-            remainingAccounts: remainingAccounts,
-        });
-    }
-    async liquidatePerpPnlForDeposit(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer)), [], this.opts);
-        return txSig;
-    }
-    async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
-        const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
-            writableMarketIndex: perpMarketIndex,
-            writableBankIndexes: [assetBankIndex],
-        });
-        return await this.program.instruction.liquidatePerpPnlForDeposit(perpMarketIndex, assetBankIndex, maxPnlTransfer, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                authority: this.wallet.publicKey,
-                user: userAccountPublicKey,
-                liquidator: liquidatorPublicKey,
-            },
-            remainingAccounts: remainingAccounts,
-        });
-    }
-    getRemainingAccountsForLiquidation(params) {
-        const liquidateeUserAccount = params.userAccount;
-        const oracleAccountMap = new Map();
-        const bankAccountMap = new Map();
-        const marketAccountMap = new Map();
-        for (const bankBalance of liquidateeUserAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        for (const position of liquidateeUserAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(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,
-                });
-            }
-        }
-        const userAccountAndSlot = this.getUserAccountAndSlot();
-        if (!userAccountAndSlot) {
-            throw Error('No user account found. Most likely user account does not exist or failed to fetch account');
-        }
-        const { data: userAccount, slot: lastUserPositionsSlot } = userAccountAndSlot;
-        for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
-            // if cache has more recent slot than user positions account slot, add market to remaining accounts
-            // otherwise remove from slot
-            if (slot > lastUserPositionsSlot) {
-                const marketAccount = this.getMarketAccount(marketIndexNum);
-                marketAccountMap.set(marketIndexNum, {
-                    pubkey: marketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-                    pubkey: marketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-            }
-            else {
-                this.marketLastSlotCache.delete(marketIndexNum);
-            }
-        }
-        for (const bankBalance of userAccount.bankBalances) {
-            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
-                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
-                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
-                    pubkey: bankAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bankAccount.oracle.toString(), {
-                        pubkey: bankAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        for (const position of userAccount.positions) {
-            if (!(0, position_1.positionIsAvailable)(position)) {
-                const market = this.getMarketAccount(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.writableMarketIndex) {
-            const market = this.getMarketAccount(params.writableMarketIndex);
-            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.writableBankIndexes) {
-            for (const writableBankIndex of params.writableBankIndexes) {
-                const bank = this.getBankAccount(writableBankIndex);
-                bankAccountMap.set(bank.bankIndex.toNumber(), {
-                    pubkey: bank.pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                });
-                if (!bank.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(bank.oracle.toString(), {
-                        pubkey: bank.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
-            }
-        }
-        return [
-            ...oracleAccountMap.values(),
-            ...bankAccountMap.values(),
-            ...marketAccountMap.values(),
-        ];
-    }
-    async updateFundingRate(oracle, marketIndex) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateFundingRateIx(oracle, marketIndex)), [], this.opts);
-        return txSig;
-    }
-    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);
-    }
-    getOracleDataForMarket(marketIndex) {
-        const oracleKey = this.getMarketAccount(marketIndex).amm.oracle;
-        const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
-        return oracleData;
-    }
-}
-exports.ClearingHouse = ClearingHouse;