@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.14

package/lib/clearingHouse.js

@@ -44,6 +44,8 @@ const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketC
 const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
 const config_1 = require("./config");
+const banks_1 = require("./constants/banks");
+const clearingHouseUserStats_1 = require("./clearingHouseUserStats");
 /**
  * # 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.
@@ -71,6 +73,13 @@ class ClearingHouse {
                     type: 'websocket',
                 };
         this.createUsers(userIds, this.userAccountSubscriptionConfig);
+        if (config.userStats) {
+            this.userStats = new clearingHouseUserStats_1.ClearingHouseUserStats({
+                clearingHouse: this,
+                userStatsAccountPublicKey: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey),
+                accountSubscription: this.userAccountSubscriptionConfig,
+            });
+        }
         let marketIndexes = config.marketIndexes;
         let bankIndexes = config.bankIndexes;
         let oracleInfos = config.oracleInfos;
@@ -111,6 +120,9 @@ class ClearingHouse {
     }
     async subscribe() {
         const subscribePromises = this.subscribeUsers().concat(this.accountSubscriber.subscribe());
+        if (this.userStats !== undefined) {
+            subscribePromises.concat(this.userStats.subscribe());
+        }
         this.isSubscribed = (await Promise.all(subscribePromises)).reduce((success, prevSuccess) => success && prevSuccess);
         return this.isSubscribed;
     }
@@ -127,6 +139,9 @@ class ClearingHouse {
     }
     async unsubscribe() {
         const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
+        if (this.userStats !== undefined) {
+            unsubscribePromises.concat(this.userStats.unsubscribe());
+        }
         await Promise.all(unsubscribePromises);
         this.isSubscribed = false;
     }
@@ -187,6 +202,7 @@ class ClearingHouse {
             await Promise.all(this.subscribeUsers());
         }
         this.activeUserId = activeUserId;
+        this.userStatsAccountPublicKey = undefined;
     }
     async switchActiveUser(userId) {
         this.activeUserId = userId;
@@ -201,7 +217,12 @@ class ClearingHouse {
     }
     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 tx = new web3_js_1.Transaction();
+        if (userId === 0) {
+            // not the safest assumption, can explicitly check if user stats account exists if it causes problems
+            tx.add(await this.getInitializeUserStatsIx());
+        }
+        tx.add(initializeUserAccountIx);
         const { txSig } = await this.txSender.send(tx, [], this.opts);
         return [txSig, userAccountPublicKey];
     }
@@ -211,6 +232,7 @@ class ClearingHouse {
         const initializeUserAccountIx = await this.program.instruction.initializeUser(userId, nameBuffer, {
             accounts: {
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
                 payer: this.wallet.publicKey,
                 rent: anchor.web3.SYSVAR_RENT_PUBKEY,
@@ -220,6 +242,18 @@ class ClearingHouse {
         });
         return [userAccountPublicKey, initializeUserAccountIx];
     }
+    async getInitializeUserStatsIx() {
+        return await this.program.instruction.initializeUserStats({
+            accounts: {
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                payer: this.wallet.publicKey,
+                rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
     getUser(userId) {
         userId = userId !== null && userId !== void 0 ? userId : this.activeUserId;
         if (!this.users.has(userId)) {
@@ -230,6 +264,16 @@ class ClearingHouse {
     getUsers() {
         return [...this.users.values()];
     }
+    getUserStats() {
+        return this.userStats;
+    }
+    getUserStatsAccountPublicKey() {
+        if (this.userStatsAccountPublicKey) {
+            return this.userStatsAccountPublicKey;
+        }
+        this.userStatsAccountPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey);
+        return this.userStatsAccountPublicKey;
+    }
     async getUserAccountPublicKey() {
         return this.getUser().userAccountPublicKey;
     }
@@ -284,8 +328,7 @@ class ClearingHouse {
                 marketAccountMap.set(marketIndexNum, {
                     pubkey: marketAccount.pubkey,
                     isSigner: false,
-                    // isWritable: false, // TODO
-                    isWritable: true,
+                    isWritable: false,
                 });
                 oracleAccountMap.set(marketAccount.pubkey.toString(), {
                     pubkey: marketAccount.amm.oracle,
@@ -294,6 +337,19 @@ class ClearingHouse {
                 });
             }
         }
+        if (params.readableMarketIndex) {
+            const marketAccount = this.getMarketAccount(params.readableMarketIndex.toNumber());
+            marketAccountMap.set(params.readableMarketIndex.toNumber(), {
+                pubkey: marketAccount.pubkey,
+                isSigner: false,
+                isWritable: true,
+            });
+            oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+                pubkey: marketAccount.amm.oracle,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
         if (params.writableMarketIndex) {
             const marketAccount = this.getMarketAccount(params.writableMarketIndex.toNumber());
             marketAccountMap.set(params.writableMarketIndex.toNumber(), {
@@ -355,9 +411,27 @@ class ClearingHouse {
         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 tx = new web3_js_1.Transaction();
+        const additionalSigners = [];
+        const bank = this.getBankAccount(bankIndex);
+        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolBank && collateralAccountPublicKey.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
+            collateralAccountPublicKey = pubkey;
+            ixs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
         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);
+        tx.add(depositCollateralIx);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, collateralAccountPublicKey, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
     async getDepositInstruction(amount, bankIndex, userTokenAccount, userId, reduceOnly = false, userInitialized = true) {
@@ -399,40 +473,132 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async checkIfAccountExists(account) {
+        try {
+            const accountInfo = await this.connection.getAccountInfo(account);
+            return accountInfo && true;
+        }
+        catch (e) {
+            // Doesn't already exist
+            return false;
+        }
+    }
+    async getSolWithdrawalIxs(bankIndex, amount) {
+        const result = {
+            ixs: [],
+            signers: [],
+            pubkey: web3_js_1.PublicKey.default,
+        };
+        // Create a temporary wrapped SOL account to store the SOL that we're withdrawing
+        const authority = this.wallet.publicKey;
+        const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
+        result.pubkey = pubkey;
+        ixs.forEach((ix) => {
+            result.ixs.push(ix);
+        });
+        signers.forEach((ix) => {
+            result.signers.push(ix);
+        });
+        const withdrawIx = await this.getWithdrawIx(amount, bankIndex, pubkey, true);
+        result.ixs.push(withdrawIx);
+        result.ixs.push(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, pubkey, authority, authority, []));
+        return result;
+    }
+    async getWrappedSolAccountCreationIxs(amount) {
+        const wrappedSolAccount = new web3_js_1.Keypair();
+        const result = {
+            ixs: [],
+            signers: [],
+            pubkey: wrappedSolAccount.publicKey,
+        };
+        const rentSpaceLamports = new anchor_1.BN(web3_js_1.LAMPORTS_PER_SOL / 100);
+        const depositAmountLamports = amount.add(rentSpaceLamports);
+        const authority = this.wallet.publicKey;
+        result.ixs.push(web3_js_1.SystemProgram.createAccount({
+            fromPubkey: authority,
+            newAccountPubkey: wrappedSolAccount.publicKey,
+            lamports: depositAmountLamports.toNumber(),
+            space: 165,
+            programId: spl_token_1.TOKEN_PROGRAM_ID,
+        }));
+        result.ixs.push(spl_token_1.Token.createInitAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, banks_1.WRAPPED_SOL_MINT, wrappedSolAccount.publicKey, authority));
+        result.signers.push(wrappedSolAccount);
+        return result;
+    }
     /**
      * Creates the Clearing House User account for a user, and deposits some initial collateral
-     * @param userId
-     * @param name
      * @param amount
      * @param userTokenAccount
+     * @param bankIndex
+     * @param userId
+     * @param name
      * @param fromUserId
      * @returns
      */
     async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, bankIndex = new anchor_1.BN(0), userId = 0, name = userName_1.DEFAULT_USER_NAME, fromUserId) {
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
+        const additionalSigners = [];
+        const bank = this.getBankAccount(bankIndex);
+        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const tx = new web3_js_1.Transaction();
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolBank && userTokenAccount.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs: startIxs, signers, pubkey, } = await this.getWrappedSolAccountCreationIxs(amount);
+            userTokenAccount = pubkey;
+            startIxs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
         const depositCollateralIx = fromUserId != null
             ? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
             : await this.getDepositInstruction(amount, bankIndex, userTokenAccount, userId, false, false);
-        const tx = new web3_js_1.Transaction()
-            .add(initializeUserAccountIx)
-            .add(depositCollateralIx);
-        const { txSig } = await this.txSender.send(tx, []);
+        if (userId === 0) {
+            tx.add(await this.getInitializeUserStatsIx());
+        }
+        tx.add(initializeUserAccountIx).add(depositCollateralIx);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return [txSig, userAccountPublicKey];
     }
     async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, 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 tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToIx);
+        if (userId === 0) {
+            tx.add(await this.getInitializeUserStatsIx());
+        }
+        tx.add(initializeUserAccountIx).add(depositCollateralIx);
         const txSig = await this.program.provider.sendAndConfirm(tx, []);
         return [txSig, userAccountPublicKey];
     }
     async withdraw(amount, bankIndex, userTokenAccount, reduceOnly = false) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly)), [], this.opts);
+        const tx = new web3_js_1.Transaction();
+        const additionalSigners = [];
+        const bank = this.getBankAccount(bankIndex);
+        const isSolBank = bank.mint.equals(banks_1.WRAPPED_SOL_MINT);
+        const authority = this.wallet.publicKey;
+        const createWSOLTokenAccount = isSolBank && userTokenAccount.equals(authority);
+        if (createWSOLTokenAccount) {
+            const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(amount);
+            userTokenAccount = pubkey;
+            ixs.forEach((ix) => {
+                tx.add(ix);
+            });
+            signers.forEach((signer) => additionalSigners.push(signer));
+        }
+        const withdrawCollateral = await this.getWithdrawIx(amount, bank.bankIndex, userTokenAccount, reduceOnly);
+        tx.add(withdrawCollateral);
+        // Close the wrapped sol account at the end of the transaction
+        if (createWSOLTokenAccount) {
+            tx.add(spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccount, authority, authority, []));
+        }
+        const { txSig } = await this.txSender.send(tx, additionalSigners, this.opts);
         return txSig;
     }
     async getWithdrawIx(amount, bankIndex, userTokenAccount, reduceOnly = false) {
@@ -487,6 +653,82 @@ class ClearingHouse {
             },
         });
     }
+    async settleLP(settleeUserAccountPublicKey, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.settleLPIx(settleeUserAccountPublicKey, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async settleLPIx(settleeUserAccountPublicKey, marketIndex) {
+        const settleeUserAccount = (await this.program.account.user.fetch(settleeUserAccountPublicKey));
+        const userPositions = settleeUserAccount.positions;
+        const remainingAccounts = [];
+        let foundMarket = false;
+        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: true,
+                    isSigner: false,
+                });
+                if (marketIndex.eq(position.marketIndex)) {
+                    foundMarket = true;
+                }
+            }
+        }
+        if (!foundMarket) {
+            console.log('Warning: lp is not in the market specified -- tx will likely fail');
+        }
+        return this.program.instruction.settleLp(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: settleeUserAccountPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async removeLiquidity(marketIndex, sharesToBurn) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)), [], this.opts);
+        return txSig;
+    }
+    async getRemoveLiquidityIx(marketIndex, sharesToBurn) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            writableMarketIndex: marketIndex,
+        });
+        if (sharesToBurn == undefined) {
+            const userAccount = this.getUserAccount();
+            const marketPosition = userAccount.positions.filter((position) => position.marketIndex.eq(marketIndex))[0];
+            sharesToBurn = marketPosition.lpShares;
+            console.log('burning lp shares:', sharesToBurn.toString());
+        }
+        return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async addLiquidity(amount, marketIndex) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getAddLiquidityIx(amount, marketIndex)), [], this.opts);
+        this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
+        return txSig;
+    }
+    async getAddLiquidityIx(amount, marketIndex) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            writableMarketIndex: marketIndex,
+        });
+        return this.program.instruction.addLiquidity(amount, marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
     async openPosition(direction, amount, marketIndex, limitPrice) {
         return await this.placeAndTake({
             orderType: types_1.OrderType.MARKET,
@@ -508,12 +750,13 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
-            writableMarketIndex: orderParams.marketIndex,
+            readableMarketIndex: orderParams.marketIndex,
         });
         return await this.program.instruction.placeOrder(orderParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -593,29 +836,21 @@ class ClearingHouse {
         return txSig;
     }
     async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const fillerPublicKey = await this.getUserAccountPublicKey();
+        const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         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,
+                    isWritable: false,
                 });
                 if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
                     oracleAccountMap.set(bankAccount.oracle.toString(), {
@@ -632,7 +867,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: true,
+                    isWritable: false,
                     isSigner: false,
                 });
                 oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -642,6 +877,16 @@ class ClearingHouse {
                 });
             }
         }
+        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,
+        });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
             ...bankAccountMap.values(),
@@ -653,6 +898,11 @@ class ClearingHouse {
                 isWritable: true,
                 isSigner: false,
             });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isWritable: true,
+                isSigner: false,
+            });
         }
         const orderId = order.orderId;
         const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
@@ -660,7 +910,9 @@ class ClearingHouse {
             accounts: {
                 state: await this.getStatePublicKey(),
                 filler: fillerPublicKey,
+                fillerStats: fillerStatsPublicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -677,23 +929,13 @@ class ClearingHouse {
         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,
+                    isWritable: false,
                 });
                 if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
                     oracleAccountMap.set(bankAccount.oracle.toString(), {
@@ -710,7 +952,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: true,
+                    isWritable: false,
                     isSigner: false,
                 });
                 oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -720,6 +962,16 @@ class ClearingHouse {
                 });
             }
         }
+        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,
+        });
         const remainingAccounts = [
             ...oracleAccountMap.values(),
             ...bankAccountMap.values(),
@@ -743,6 +995,7 @@ class ClearingHouse {
     }
     async getPlaceAndTakeIx(orderParams, makerInfo) {
         orderParams = this.getOrderParams(orderParams);
+        const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
@@ -756,11 +1009,17 @@ class ClearingHouse {
                 isSigner: false,
                 isWritable: true,
             });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isSigner: false,
+                isWritable: true,
+            });
         }
         return await this.program.instruction.placeAndTake(orderParams, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -773,22 +1032,19 @@ class ClearingHouse {
     }
     async getPlaceAndMakeIx(orderParams, takerInfo) {
         orderParams = this.getOrderParams(orderParams);
+        const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         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,
+                userStats: userStatsPublicKey,
                 taker: takerInfo.taker,
+                takerStats: takerInfo.takerStats,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -799,7 +1055,7 @@ class ClearingHouse {
      * @param marketIndex
      * @returns
      */
-    async closePosition(marketIndex) {
+    async closePosition(marketIndex, limitPrice) {
         const userPosition = this.getUser().getUserPosition(marketIndex);
         if (!userPosition) {
             throw Error(`No position in market ${marketIndex.toString()}`);
@@ -808,8 +1064,9 @@ class ClearingHouse {
             orderType: types_1.OrderType.MARKET,
             marketIndex,
             direction: (0, position_1.findDirectionToClose)(userPosition),
-            baseAssetAmount: userPosition.baseAssetAmount,
+            baseAssetAmount: userPosition.baseAssetAmount.abs(),
             reduceOnly: true,
+            price: limitPrice,
         });
     }
     async settlePNLs(users, marketIndex) {
@@ -834,7 +1091,7 @@ class ClearingHouse {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: true,
+                    isWritable: false,
                     isSigner: false,
                 });
                 oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -896,7 +1153,9 @@ class ClearingHouse {
         return txSig;
     }
     async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsForLiquidation({
             writableMarketIndex: marketIndex,
             userAccount,
@@ -906,7 +1165,9 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
@@ -973,6 +1234,46 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
+    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+            writableMarketIndex: marketIndex,
+            userAccount,
+        });
+        return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: userAccountPublicKey,
+                liquidator: liquidatorPublicKey,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
+    async resolveBorrowBankruptcy(userAccountPublicKey, userAccount, bankIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex) {
+        const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+            writableBankIndexes: [bankIndex],
+            userAccount,
+        });
+        return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
+            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();

package/lib/clearingHouseConfig.d.ts

@@ -18,6 +18,7 @@ export declare type ClearingHouseConfig = {
     bankIndexes?: BN[];
     oracleInfos?: OracleInfo[];
     env?: DriftEnv;
+    userStats?: boolean;
 };
 declare type ClearingHouseSubscriptionConfig = {
     type: 'websocket';