@drift-labs/sdk 0.2.0-master.10 → 0.2.0-master.13

package/lib/clearingHouse.js

@@ -44,6 +44,7 @@ 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");
 /**
  * # 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.
@@ -284,8 +285,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 +294,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 +368,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,30 +430,99 @@ 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, []);
+        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, mockUSDCFaucet, amount) {
-        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
+    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, new anchor_1.BN(0), associateTokenPublicKey, userId, false, false);
+        const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, associateTokenPublicKey, userId, false, false);
         const tx = new web3_js_1.Transaction()
             .add(createAssociatedAccountIx)
             .add(mintToIx)
@@ -432,7 +532,27 @@ class ClearingHouse {
         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) {
@@ -508,7 +628,7 @@ 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: {
@@ -599,23 +719,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(), {
@@ -632,7 +742,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 +752,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(),
@@ -677,23 +797,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 +820,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 +830,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(),
@@ -834,7 +954,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(), {
@@ -891,54 +1011,217 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
-    async liquidate(liquidateeUserAccountPublicKey) {
-        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getLiquidateIx(liquidateeUserAccountPublicKey)), [], this.opts);
+    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 getLiquidateIx(liquidateeUserAccountPublicKey) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const liquidateeUserAccount = (await this.program.account.user.fetch(liquidateeUserAccountPublicKey));
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
+    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,
             },
-        ];
-        const marketAccountInfos = [];
-        const oracleAccountInfos = [];
+            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);
-                const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, position.marketIndex);
-                marketAccountInfos.push({
-                    pubkey: marketPublicKey,
-                    isWritable: true,
+                marketAccountMap.set(position.marketIndex.toNumber(), {
+                    pubkey: market.pubkey,
+                    isWritable: false,
                     isSigner: false,
                 });
-                oracleAccountInfos.push({
+                oracleAccountMap.set(market.amm.oracle.toString(), {
                     pubkey: market.amm.oracle,
                     isWritable: false,
                     isSigner: false,
                 });
             }
         }
-        const remainingAccounts = oracleAccountInfos.concat(bankAccountInfos.concat(marketAccountInfos));
-        const state = this.getStateAccount();
-        const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
-        return await this.program.instruction.liquidate({
-            accounts: {
-                state: await this.getStatePublicKey(),
-                authority: this.wallet.publicKey,
-                user: liquidateeUserAccountPublicKey,
-                liquidator: userAccountPublicKey,
-                bankVault: quoteAssetBankAccount.vault,
-                bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
-                insuranceVault: state.insuranceVault,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-            remainingAccounts: remainingAccounts,
-        });
+        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);

package/lib/clearingHouseUser.d.ts

@@ -61,48 +61,43 @@ export declare class ClearingHouseUser {
     getFreeCollateral(): BN;
     getInitialMarginRequirement(): BN;
     /**
-     * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
      */
-    getPartialMarginRequirement(): BN;
+    getMaintenanceMarginRequirement(): BN;
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN;
-    /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getUnsettledPNL(marketIndex?: BN): BN;
+    getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates unrealized funding payment pnl
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex?: BN): BN;
-    getTotalLiability(): BN;
-    getCollateralValue(bankIndex?: BN): BN;
+    getBankLiabilityValue(bankIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
+    getBankAssetValue(bankIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
+    getNetBankValue(withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
-     * TODO: rename to total equity (for perpetuals swaps)
      * @returns : Precision QUOTE_PRECISION
      */
-    getTotalCollateral(): BN;
+    getTotalCollateral(marginCategory?: MarginCategory): BN;
     /**
-     * calculates sum of position value across all positions
+     * calculates sum of position value across all positions in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalPositionValue(): BN;
     /**
-     * calculates position value from closing 100%
+     * calculates position value in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getPositionValue(marketIndex: BN, oraclePriceData: OraclePriceData): BN;
     getPositionSide(currentPosition: Pick<UserPosition, 'baseAssetAmount'>): PositionDirection | undefined;
     /**
-     * calculates average exit price for closing 100% of position
+     * calculates average exit price (optionally for closing up to 100% of position)
      * @returns : Precision MARK_PRICE_PRECISION
      */
-    getPositionEstimatedExitPriceAndPnl(position: UserPosition, amountToClose?: BN): [BN, BN];
+    getPositionEstimatedExitPriceAndPnl(position: UserPosition, amountToClose?: BN, useAMMClose?: boolean): [BN, BN];
     /**
      * calculates current user leverage across all positions
      * @returns : Precision TEN_THOUSAND
@@ -132,7 +127,7 @@ export declare class ClearingHouseUser {
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPrice(marketPosition: Pick<UserPosition, 'marketIndex'>, positionBaseSizeChange?: BN, partial?: boolean): BN;
+    liquidationPrice(marketPosition: Pick<UserPosition, 'marketIndex'>, positionBaseSizeChange?: BN): BN;
     /**
      * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
      * @param positionMarketIndex