@drift-labs/sdk 0.1.27 → 0.1.29-master.1

package/src/clearingHouse.js

@@ -1,769 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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 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 utils_1 = require("./tx/utils");
-const clearingHouse_1 = require("./factory/clearingHouse");
-const numericConstants_1 = require("./constants/numericConstants");
-/**
- * # 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) {
-        this._isSubscribed = false;
-        this.connection = connection;
-        this.wallet = wallet;
-        this.opts = opts;
-        this.program = program;
-        this.accountSubscriber = accountSubscriber;
-        this.eventEmitter = this.accountSubscriber.eventEmitter;
-        this.txSender = txSender;
-    }
-    get isSubscribed() {
-        return this._isSubscribed && this.accountSubscriber.isSubscribed;
-    }
-    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.Provider.defaultOptions()) {
-        const config = (0, clearingHouse_1.getWebSocketClearingHouseConfig)(connection, wallet, clearingHouseProgramId, opts);
-        return (0, clearingHouse_1.getClearingHouse)(config);
-    }
-    /**
-     *
-     * @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
-     */
-    async subscribe(optionalSubscriptions) {
-        this.isSubscribed = await this.accountSubscriber.subscribe(optionalSubscriptions);
-        return this.isSubscribed;
-    }
-    /**
-     * Shorthand function to subscribe to all available Clearing House State Accounts
-     * @returns Promise<boolean> : SubscriptionSuccess
-     */
-    async subscribeToAll() {
-        return this.subscribe([
-            'curveHistoryAccount',
-            'depositHistoryAccount',
-            'fundingPaymentHistoryAccount',
-            'fundingRateHistoryAccount',
-            'liquidationHistoryAccount',
-            'tradeHistoryAccount',
-            'orderHistoryAccount',
-        ]);
-    }
-    /**
-     *	Forces the accountSubscriber to fetch account updates from rpc
-     */
-    async fetchAccounts() {
-        await this.accountSubscriber.fetch();
-    }
-    /**
-     * Unsubscribe from all currently subscribed state accounts
-     */
-    async unsubscribe() {
-        await this.accountSubscriber.unsubscribe();
-        this.isSubscribed = false;
-    }
-    async getStatePublicKey() {
-        if (this.statePublicKey) {
-            return this.statePublicKey;
-        }
-        this.statePublicKey = await (0, addresses_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-        return this.statePublicKey;
-    }
-    getStateAccount() {
-        return this.accountSubscriber.getStateAccount();
-    }
-    getMarketsAccount() {
-        return this.accountSubscriber.getMarketsAccount();
-    }
-    getMarket(marketIndex) {
-        if (marketIndex instanceof anchor_1.BN) {
-            marketIndex = marketIndex.toNumber();
-        }
-        return this.getMarketsAccount().markets[marketIndex];
-    }
-    getFundingPaymentHistoryAccount() {
-        return this.accountSubscriber.getFundingPaymentHistoryAccount();
-    }
-    getFundingRateHistoryAccount() {
-        return this.accountSubscriber.getFundingRateHistoryAccount();
-    }
-    getTradeHistoryAccount() {
-        return this.accountSubscriber.getTradeHistoryAccount();
-    }
-    getLiquidationHistoryAccount() {
-        return this.accountSubscriber.getLiquidationHistoryAccount();
-    }
-    getDepositHistoryAccount() {
-        return this.accountSubscriber.getDepositHistoryAccount();
-    }
-    getCurveHistoryAccount() {
-        return this.accountSubscriber.getCurveHistoryAccount();
-    }
-    getOrderHistoryAccount() {
-        return this.accountSubscriber.getOrderHistoryAccount();
-    }
-    async getOrderStatePublicKey() {
-        if (this.orderStatePublicKey) {
-            return this.orderStatePublicKey;
-        }
-        this.orderStatePublicKey = await (0, addresses_1.getOrderStateAccountPublicKey)(this.program.programId);
-        return this.orderStatePublicKey;
-    }
-    getOrderStateAccount() {
-        return this.accountSubscriber.getOrderStateAccount();
-    }
-    /**
-     * Update the wallet to use for clearing house transactions and linked user account
-     * @param newWallet
-     */
-    updateWallet(newWallet) {
-        const newProvider = new anchor_1.Provider(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;
-        this.userAccountPublicKey = undefined;
-        this.userAccount = undefined;
-        this.userOrdersAccountPublicKey = undefined;
-        this.userOrdersExist = undefined;
-    }
-    async initializeUserAccount() {
-        const [userPositionsAccount, userAccountPublicKey, initializeUserAccountIx, initializeUserOrdersAccountIx,] = await this.getInitializeUserInstructions();
-        const tx = new web3_js_1.Transaction()
-            .add(initializeUserAccountIx)
-            .add(initializeUserOrdersAccountIx);
-        const txSig = await this.txSender.send(tx, [userPositionsAccount], this.opts);
-        return [txSig, userAccountPublicKey];
-    }
-    async getInitializeUserInstructions() {
-        const [userAccountPublicKey, userAccountNonce] = await (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 = await spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.whitelistMint, this.wallet.publicKey);
-            remainingAccounts.push({
-                pubkey: associatedTokenPublicKey,
-                isWritable: false,
-                isSigner: false,
-            });
-        }
-        const userPositions = new web3_js_1.Keypair();
-        const initializeUserAccountIx = await 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: await this.getStatePublicKey(),
-            },
-            remainingAccounts: remainingAccounts,
-        });
-        const initializeUserOrdersAccountIx = await this.getInitializeUserOrdersInstruction(userAccountPublicKey);
-        return [
-            userPositions,
-            userAccountPublicKey,
-            initializeUserAccountIx,
-            initializeUserOrdersAccountIx,
-        ];
-    }
-    async getInitializeUserOrdersInstruction(userAccountPublicKey) {
-        if (!userAccountPublicKey) {
-            userAccountPublicKey = await this.getUserAccountPublicKey();
-        }
-        const [userOrdersAccountPublicKey, userOrdersAccountNonce] = await (0, addresses_1.getUserOrdersAccountPublicKeyAndNonce)(this.program.programId, userAccountPublicKey);
-        return await 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: await this.getStatePublicKey(),
-            },
-        });
-    }
-    /**
-     * Get the address for the Clearing House User's account. NOT the user's wallet address.
-     * @returns
-     */
-    async getUserAccountPublicKey() {
-        if (this.userAccountPublicKey) {
-            return this.userAccountPublicKey;
-        }
-        this.userAccountPublicKey = await (0, addresses_1.getUserAccountPublicKey)(this.program.programId, this.wallet.publicKey);
-        return this.userAccountPublicKey;
-    }
-    async getUserAccount() {
-        if (this.userAccount) {
-            return this.userAccount;
-        }
-        this.userAccount = (await this.program.account.user.fetch(await this.getUserAccountPublicKey()));
-        return this.userAccount;
-    }
-    /**
-     * Get the address for the Clearing House User Order's account. NOT the user's wallet address.
-     * @returns
-     */
-    async getUserOrdersAccountPublicKey() {
-        if (this.userOrdersAccountPublicKey) {
-            return this.userOrdersAccountPublicKey;
-        }
-        this.userOrdersAccountPublicKey = await (0, addresses_1.getUserOrdersAccountPublicKey)(this.program.programId, await this.getUserAccountPublicKey());
-        return this.userOrdersAccountPublicKey;
-    }
-    async userOrdersAccountExists() {
-        if (this.userOrdersExist) {
-            return this.userOrdersExist;
-        }
-        const userOrdersAccountRPCResponse = await this.connection.getParsedAccountInfo(await this.getUserOrdersAccountPublicKey());
-        this.userOrdersExist = userOrdersAccountRPCResponse.value !== null;
-        return this.userOrdersExist;
-    }
-    async depositCollateral(amount, collateralAccountPublicKey, userPositionsAccountPublicKey) {
-        const depositCollateralIx = await this.getDepositCollateralInstruction(amount, collateralAccountPublicKey, userPositionsAccountPublicKey);
-        const tx = new web3_js_1.Transaction().add(depositCollateralIx);
-        return await this.txSender.send(tx);
-    }
-    async getDepositCollateralInstruction(amount, collateralAccountPublicKey, userPositionsAccountPublicKey) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        if (!userPositionsAccountPublicKey) {
-            userPositionsAccountPublicKey = (await this.getUserAccount()).positions;
-        }
-        const state = this.getStateAccount();
-        return await this.program.instruction.depositCollateral(amount, {
-            accounts: {
-                state: await 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,
-            },
-        });
-    }
-    /**
-     * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param amount
-     * @param collateralAccountPublicKey
-     * @returns
-     */
-    async initializeUserAccountAndDepositCollateral(amount, collateralAccountPublicKey) {
-        const [userPositionsAccount, userAccountPublicKey, initializeUserAccountIx, initializeUserOrdersAccountIx,] = await this.getInitializeUserInstructions();
-        const depositCollateralIx = await this.getDepositCollateralInstruction(amount, collateralAccountPublicKey, userPositionsAccount.publicKey);
-        const tx = new web3_js_1.Transaction()
-            .add(initializeUserAccountIx)
-            .add(initializeUserOrdersAccountIx)
-            .add(depositCollateralIx);
-        const txSig = await this.program.provider.send(tx, [userPositionsAccount]);
-        return [txSig, userAccountPublicKey];
-    }
-    async initializeUserAccountForDevnet(mockUSDCFaucet, amount) {
-        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
-        const [userPositionsAccount, userAccountPublicKey, initializeUserAccountIx, initializeUserOrdersAccountIx,] = await this.getInitializeUserInstructions();
-        const depositCollateralIx = await 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 = await this.program.provider.send(tx, [userPositionsAccount]);
-        return [txSig, userAccountPublicKey];
-    }
-    async deleteUser() {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const user = await this.program.account.user.fetch(userAccountPublicKey);
-        const deleteUserTx = await this.program.transaction.deleteUser({
-            accounts: {
-                user: userAccountPublicKey,
-                userPositions: user.positions,
-                authority: this.wallet.publicKey,
-            },
-        });
-        return this.txSender.send(deleteUserTx, [], this.opts);
-    }
-    async withdrawCollateral(amount, collateralAccountPublicKey) {
-        return this.txSender.send((0, utils_1.wrapInTx)(await this.getWithdrawCollateralIx(amount, collateralAccountPublicKey)), [], this.opts);
-    }
-    async getWithdrawCollateralIx(amount, collateralAccountPublicKey) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const user = await this.program.account.user.fetch(userAccountPublicKey);
-        const state = this.getStateAccount();
-        return await this.program.instruction.withdrawCollateral(amount, {
-            accounts: {
-                state: await 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,
-            },
-        });
-    }
-    async openPosition(direction, amount, marketIndex, limitPrice, discountToken, referrer) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getOpenPositionIx(direction, amount, marketIndex, limitPrice, discountToken, referrer)), [], this.opts);
-    }
-    async getOpenPositionIx(direction, amount, marketIndex, limitPrice, discountToken, referrer) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await 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,
-                isSigner: false,
-            });
-        }
-        if (referrer) {
-            optionalAccounts.referrer = true;
-            remainingAccounts.push({
-                pubkey: referrer,
-                isWritable: true,
-                isSigner: false,
-            });
-        }
-        const priceOracle = this.getMarketsAccount().markets[marketIndex.toNumber()].amm.oracle;
-        const state = this.getStateAccount();
-        return await this.program.instruction.openPosition(direction, amount, marketIndex, limitPrice, optionalAccounts, {
-            accounts: {
-                state: await 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,
-        });
-    }
-    async initializeUserOrdersThenPlaceOrder(orderParams, discountToken, referrer) {
-        const instructions = [];
-        const userOrdersAccountExists = await this.userOrdersAccountExists();
-        if (!userOrdersAccountExists) {
-            instructions.push(await this.getInitializeUserOrdersInstruction());
-        }
-        instructions.push(await this.getPlaceOrderIx(orderParams, discountToken, referrer));
-        const tx = new web3_js_1.Transaction();
-        for (const instruction of instructions) {
-            tx.add(instruction);
-        }
-        return await this.txSender.send(tx, [], this.opts);
-    }
-    async placeOrder(orderParams, discountToken, referrer) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams, discountToken, referrer)), [], this.opts);
-    }
-    async getPlaceOrderIx(orderParams, discountToken, referrer) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await 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,
-                isSigner: false,
-            });
-        }
-        if (orderParams.optionalAccounts.referrer) {
-            if (!referrer) {
-                throw Error('Optional accounts specified referrer but no referrer present');
-            }
-            remainingAccounts.push({
-                pubkey: referrer,
-                isWritable: false,
-                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 await this.program.instruction.placeOrder(orderParams, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-                markets: state.markets,
-                userOrders: await this.getUserOrdersAccountPublicKey(),
-                userPositions: userAccount.positions,
-                fundingPaymentHistory: state.fundingPaymentHistory,
-                fundingRateHistory: state.fundingRateHistory,
-                orderState: await this.getOrderStatePublicKey(),
-                orderHistory: orderState.orderHistory,
-            },
-            remainingAccounts,
-        });
-    }
-    async cancelOrder(orderId, oracle) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrderIx(orderId, oracle)), [], this.opts);
-    }
-    async getCancelOrderIx(orderId, oracle) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await this.getUserAccount();
-        const state = this.getStateAccount();
-        const orderState = this.getOrderStateAccount();
-        const remainingAccounts = [];
-        if (oracle) {
-            remainingAccounts.push({
-                pubkey: oracle,
-                isWritable: false,
-                isSigner: false,
-            });
-        }
-        return await this.program.instruction.cancelOrder(orderId, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-                markets: state.markets,
-                userOrders: await this.getUserOrdersAccountPublicKey(),
-                userPositions: userAccount.positions,
-                fundingPaymentHistory: state.fundingPaymentHistory,
-                fundingRateHistory: state.fundingRateHistory,
-                orderState: await this.getOrderStatePublicKey(),
-                orderHistory: orderState.orderHistory,
-            },
-            remainingAccounts,
-        });
-    }
-    async cancelOrderByUserId(userOrderId, oracle) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getCancelOrderByUserIdIx(userOrderId, oracle)), [], this.opts);
-    }
-    async getCancelOrderByUserIdIx(userOrderId, oracle) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await this.getUserAccount();
-        const state = this.getStateAccount();
-        const orderState = this.getOrderStateAccount();
-        const remainingAccounts = [];
-        if (oracle) {
-            remainingAccounts.push({
-                pubkey: oracle,
-                isWritable: false,
-                isSigner: false,
-            });
-        }
-        return await this.program.instruction.cancelOrderByUserId(userOrderId, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-                markets: state.markets,
-                userOrders: await this.getUserOrdersAccountPublicKey(),
-                userPositions: userAccount.positions,
-                fundingPaymentHistory: state.fundingPaymentHistory,
-                fundingRateHistory: state.fundingRateHistory,
-                orderState: await this.getOrderStatePublicKey(),
-                orderHistory: orderState.orderHistory,
-            },
-            remainingAccounts,
-        });
-    }
-    async fillOrder(userAccountPublicKey, userOrdersAccountPublicKey, order) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getFillOrderIx(userAccountPublicKey, userOrdersAccountPublicKey, order)), [], this.opts);
-    }
-    async getFillOrderIx(userAccountPublicKey, userOrdersAccountPublicKey, order) {
-        const fillerPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await 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,
-                isWritable: true,
-                isSigner: false,
-            });
-        }
-        const orderId = order.orderId;
-        return await this.program.instruction.fillOrder(orderId, {
-            accounts: {
-                state: await 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: await this.getOrderStatePublicKey(),
-                orderHistory: orderState.orderHistory,
-                extendedCurveHistory: state.extendedCurveHistory,
-                oracle: oracle,
-            },
-            remainingAccounts,
-        });
-    }
-    async initializeUserOrdersThenPlaceAndFillOrder(orderParams, discountToken, referrer) {
-        const instructions = [];
-        const userOrdersAccountExists = await this.userOrdersAccountExists();
-        if (!userOrdersAccountExists) {
-            instructions.push(await this.getInitializeUserOrdersInstruction());
-        }
-        instructions.push(await this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer));
-        const tx = new web3_js_1.Transaction();
-        for (const instruction of instructions) {
-            tx.add(instruction);
-        }
-        return await this.txSender.send(tx, [], this.opts);
-    }
-    async placeAndFillOrder(orderParams, discountToken, referrer) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer)), [], this.opts);
-    }
-    async getPlaceAndFillOrderIx(orderParams, discountToken, referrer) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await 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,
-                isSigner: false,
-            });
-        }
-        if (orderParams.optionalAccounts.referrer) {
-            if (!referrer) {
-                throw Error('Optional accounts specified referrer but no referrer present');
-            }
-            remainingAccounts.push({
-                pubkey: referrer,
-                isWritable: true,
-                isSigner: false,
-            });
-        }
-        const state = this.getStateAccount();
-        const orderState = this.getOrderStateAccount();
-        return await this.program.instruction.placeAndFillOrder(orderParams, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
-                authority: this.wallet.publicKey,
-                markets: state.markets,
-                userOrders: await this.getUserOrdersAccountPublicKey(),
-                userPositions: userAccount.positions,
-                tradeHistory: state.tradeHistory,
-                fundingPaymentHistory: state.fundingPaymentHistory,
-                fundingRateHistory: state.fundingRateHistory,
-                orderState: await this.getOrderStatePublicKey(),
-                orderHistory: orderState.orderHistory,
-                extendedCurveHistory: state.extendedCurveHistory,
-                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
-     */
-    async closePosition(marketIndex, discountToken, referrer) {
-        return await this.txSender.send((0, utils_1.wrapInTx)(await this.getClosePositionIx(marketIndex, discountToken, referrer)), [], this.opts);
-    }
-    async getClosePositionIx(marketIndex, discountToken, referrer) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const userAccount = await 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,
-                isWritable: false,
-                isSigner: false,
-            });
-        }
-        if (referrer) {
-            optionalAccounts.referrer = true;
-            remainingAccounts.push({
-                pubkey: referrer,
-                isWritable: true,
-                isSigner: false,
-            });
-        }
-        const state = this.getStateAccount();
-        return await this.program.instruction.closePosition(marketIndex, optionalAccounts, {
-            accounts: {
-                state: await 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,
-        });
-    }
-    async liquidate(liquidateeUserAccountPublicKey) {
-        return this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);
-    }
-    async getLiquidateIx(liquidateeUserAccountPublicKey) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const liquidateeUserAccount = await this.program.account.user.fetch(liquidateeUserAccountPublicKey);
-        const liquidateePositions = await 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,
-                    isSigner: false,
-                });
-            }
-        }
-        const state = this.getStateAccount();
-        return await this.program.instruction.liquidate({
-            accounts: {
-                state: await 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,
-        });
-    }
-    async updateFundingRate(oracle, marketIndex) {
-        return this.txSender.send((0, utils_1.wrapInTx)(await this.getUpdateFundingRateIx(oracle, marketIndex)), [], this.opts);
-    }
-    async getUpdateFundingRateIx(oracle, marketIndex) {
-        const state = this.getStateAccount();
-        return await this.program.instruction.updateFundingRate(marketIndex, {
-            accounts: {
-                state: await this.getStatePublicKey(),
-                markets: state.markets,
-                oracle: oracle,
-                fundingRateHistory: state.fundingRateHistory,
-            },
-        });
-    }
-    async settleFundingPayment(userAccount, userPositionsAccount) {
-        return this.txSender.send((0, utils_1.wrapInTx)(await this.getSettleFundingPaymentIx(userAccount, userPositionsAccount)), [], this.opts);
-    }
-    async getSettleFundingPaymentIx(userAccount, userPositionsAccount) {
-        const state = this.getStateAccount();
-        return await this.program.instruction.settleFundingPayment({
-            accounts: {
-                state: await this.getStatePublicKey(),
-                markets: state.markets,
-                user: userAccount,
-                userPositions: userPositionsAccount,
-                fundingPaymentHistory: state.fundingPaymentHistory,
-            },
-        });
-    }
-    triggerEvent(eventName, data) {
-        this.eventEmitter.emit(eventName, data);
-    }
-}
-exports.ClearingHouse = ClearingHouse;
-//# sourceMappingURL=clearingHouse.js.map