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

package/lib/clearingHouse.js

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClearingHouse = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const spl_token_1 = require("@solana/spl-token");
+const types_1 = require("./types");
 const anchor = __importStar(require("@project-serum/anchor"));
 const clearing_house_json_1 = __importDefault(require("./idl/clearing_house.json"));
 const web3_js_1 = require("@solana/web3.js");
@@ -42,7 +43,6 @@ const pollingClearingHouseAccountSubscriber_1 = require("./accounts/pollingClear
 const webSocketClearingHouseAccountSubscriber_1 = require("./accounts/webSocketClearingHouseAccountSubscriber");
 const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
-const orderParams_1 = require("./orderParams");
 const config_1 = require("./config");
 /**
  * # ClearingHouse
@@ -371,13 +371,19 @@ class ClearingHouse {
             });
         }
         else {
-            remainingAccounts = [
-                {
-                    pubkey: this.getBankAccount(bankIndex).pubkey,
+            const bankAccount = this.getBankAccount(bankIndex);
+            if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                remainingAccounts.push({
+                    pubkey: bankAccount.oracle,
                     isSigner: false,
-                    isWritable: true,
-                },
-            ];
+                    isWritable: false,
+                });
+            }
+            remainingAccounts.push({
+                pubkey: bankAccount.pubkey,
+                isSigner: false,
+                isWritable: true,
+            });
         }
         const bank = this.getBankAccount(bankIndex);
         return await this.program.instruction.deposit(bankIndex, amount, reduceOnly, {
@@ -413,10 +419,10 @@ class ClearingHouse {
         const { txSig } = await this.txSender.send(tx, []);
         return [txSig, userAccountPublicKey];
     }
-    async initializeUserAccountForDevnet(userId = 0, name = userName_1.DEFAULT_USER_NAME, mockUSDCFaucet, amount) {
-        const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
+    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)
@@ -482,14 +488,24 @@ class ClearingHouse {
         });
     }
     async openPosition(direction, amount, marketIndex, limitPrice) {
-        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, direction, numericConstants_1.ZERO, amount, false, limitPrice));
+        return await this.placeAndTake({
+            orderType: types_1.OrderType.MARKET,
+            marketIndex,
+            direction,
+            baseAssetAmount: amount,
+            price: limitPrice,
+        });
     }
     async placeOrder(orderParams) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceOrderIx(orderParams)), [], this.opts);
         this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
         return txSig;
     }
+    getOrderParams(optionalOrderParams) {
+        return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams);
+    }
     async getPlaceOrderIx(orderParams) {
+        orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
@@ -580,44 +596,57 @@ class ClearingHouse {
         const fillerPublicKey = await this.getUserAccountPublicKey();
         const marketIndex = order.marketIndex;
         const marketAccount = this.getMarketAccount(marketIndex);
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
-            },
-        ];
-        const marketAccountInfos = [
-            {
-                pubkey: marketAccount.pubkey,
-                isWritable: true,
-                isSigner: false,
-            },
-        ];
-        const oracleAccountInfos = [
-            {
-                pubkey: marketAccount.amm.oracle,
-                isWritable: false,
-                isSigner: false,
-            },
-        ];
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        marketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: marketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+            pubkey: marketAccount.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        for (const bankBalance of userAccount.bankBalances) {
+            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
+                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+                    pubkey: bankAccount.pubkey,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
         for (const position of userAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position) &&
                 !position.marketIndex.eq(order.marketIndex)) {
                 const market = this.getMarketAccount(position.marketIndex);
-                marketAccountInfos.push({
+                marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
                     isWritable: true,
                     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 remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
         if (makerInfo) {
             remainingAccounts.push({
                 pubkey: makerInfo.maker,
@@ -645,44 +674,57 @@ class ClearingHouse {
         const fillerPublicKey = await this.getUserAccountPublicKey();
         const marketIndex = order.marketIndex;
         const marketAccount = this.getMarketAccount(marketIndex);
-        const bankAccountInfos = [
-            {
-                pubkey: this.getQuoteAssetBankAccount().pubkey,
-                isSigner: false,
-                isWritable: true,
-            },
-        ];
-        const marketAccountInfos = [
-            {
-                pubkey: marketAccount.pubkey,
-                isWritable: true,
-                isSigner: false,
-            },
-        ];
-        const oracleAccountInfos = [
-            {
-                pubkey: marketAccount.amm.oracle,
-                isWritable: false,
-                isSigner: false,
-            },
-        ];
+        const oracleAccountMap = new Map();
+        const bankAccountMap = new Map();
+        const marketAccountMap = new Map();
+        marketAccountMap.set(marketIndex.toNumber(), {
+            pubkey: marketAccount.pubkey,
+            isWritable: true,
+            isSigner: false,
+        });
+        oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+            pubkey: marketAccount.amm.oracle,
+            isWritable: false,
+            isSigner: false,
+        });
+        for (const bankBalance of userAccount.bankBalances) {
+            if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
+                const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+                bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+                    pubkey: bankAccount.pubkey,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                if (!bankAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+                    oracleAccountMap.set(bankAccount.oracle.toString(), {
+                        pubkey: bankAccount.oracle,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+            }
+        }
         for (const position of userAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position) &&
                 !position.marketIndex.eq(order.marketIndex)) {
                 const market = this.getMarketAccount(position.marketIndex);
-                marketAccountInfos.push({
+                marketAccountMap.set(position.marketIndex.toNumber(), {
                     pubkey: market.pubkey,
-                    isWritable: false,
+                    isWritable: true,
                     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 remainingAccounts = [
+            ...oracleAccountMap.values(),
+            ...bankAccountMap.values(),
+            ...marketAccountMap.values(),
+        ];
         const orderId = order.orderId;
         return await this.program.instruction.triggerOrder(orderId, {
             accounts: {
@@ -700,6 +742,7 @@ class ClearingHouse {
         return txSig;
     }
     async getPlaceAndTakeIx(orderParams, makerInfo) {
+        orderParams = this.getOrderParams(orderParams);
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
@@ -723,6 +766,34 @@ class ClearingHouse {
             remainingAccounts,
         });
     }
+    async placeAndMake(orderParams, takerInfo) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndMakeIx(orderParams, takerInfo)), [], this.opts);
+        this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+        return txSig;
+    }
+    async getPlaceAndMakeIx(orderParams, takerInfo) {
+        orderParams = this.getOrderParams(orderParams);
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            writableMarketIndex: orderParams.marketIndex,
+            writableBankIndex: numericConstants_1.QUOTE_ASSET_BANK_INDEX,
+        });
+        const takerOrderId = takerInfo.order.orderId;
+        remainingAccounts.push({
+            pubkey: takerInfo.taker,
+            isSigner: false,
+            isWritable: true,
+        });
+        return await this.program.instruction.placeAndMake(orderParams, takerOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                taker: takerInfo.taker,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     /**
      * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
      * @param marketIndex
@@ -733,7 +804,13 @@ class ClearingHouse {
         if (!userPosition) {
             throw Error(`No position in market ${marketIndex.toString()}`);
         }
-        return await this.placeAndTake((0, orderParams_1.getMarketOrderParams)(marketIndex, (0, position_1.findDirectionToClose)(userPosition), numericConstants_1.ZERO, userPosition.baseAssetAmount, true, undefined));
+        return await this.placeAndTake({
+            orderType: types_1.OrderType.MARKET,
+            marketIndex,
+            direction: (0, position_1.findDirectionToClose)(userPosition),
+            baseAssetAmount: userPosition.baseAssetAmount,
+            reduceOnly: true,
+        });
     }
     async settlePNLs(users, marketIndex) {
         const ixs = [];
@@ -814,54 +891,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

@@ -63,7 +63,7 @@ export declare class ClearingHouseUser {
     /**
      * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getPartialMarginRequirement(): BN;
+    getMaintenanceMarginRequirement(): BN;
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
@@ -132,7 +132,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

package/lib/clearingHouseUser.js

@@ -126,12 +126,12 @@ class ClearingHouseUser {
     /**
      * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
      */
-    getPartialMarginRequirement() {
+    getMaintenanceMarginRequirement() {
         return this.getUserAccount()
             .positions.reduce((marginRequirement, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
             return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex))
-                .mul(new _1.BN(market.marginRatioPartial))
+                .mul(new _1.BN(market.marginRatioMaintenance))
                 .div(numericConstants_1.MARGIN_PRECISION));
         }, numericConstants_1.ZERO)
             .add(this.getTotalLiability());
@@ -319,9 +319,6 @@ class ClearingHouseUser {
             case 'Maintenance':
                 marginRatioCategory = market.marginRatioMaintenance;
                 break;
-            case 'Partial':
-                marginRatioCategory = market.marginRatioPartial;
-                break;
             default:
                 marginRatioCategory = market.marginRatioInitial;
                 break;
@@ -342,7 +339,7 @@ class ClearingHouseUser {
     }
     canBeLiquidated() {
         const totalCollateral = this.getTotalCollateral();
-        const partialMaintenanceRequirement = this.getPartialMarginRequirement();
+        const partialMaintenanceRequirement = this.getMaintenanceMarginRequirement();
         const marginRatio = this.getMarginRatio();
         const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
         return [canLiquidate, marginRatio];
@@ -372,7 +369,7 @@ class ClearingHouseUser {
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
+    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO) {
         // solves formula for example canBeLiquidated below
         /* example: assume BTC price is $40k (examine 10% up/down)
 
@@ -413,9 +410,7 @@ class ClearingHouseUser {
                 const market = this.clearingHouse.getMarketAccount(position.marketIndex);
                 const positionValue = (0, _1.calculateBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
-                    .mul(partial
-                    ? new _1.BN(market.marginRatioPartial)
-                    : new _1.BN(market.marginRatioMaintenance))
+                    .mul(new _1.BN(market.marginRatioMaintenance))
                     .div(numericConstants_1.MARGIN_PRECISION);
                 totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
             }
@@ -428,14 +423,10 @@ class ClearingHouseUser {
             return new _1.BN(-1);
         }
         const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedMarketPositionValue
-            .mul(partial
-            ? new _1.BN(market.marginRatioPartial)
-            : new _1.BN(market.marginRatioMaintenance))
+            .mul(new _1.BN(market.marginRatioMaintenance))
             .div(numericConstants_1.MARGIN_PRECISION));
         const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
-        const marketMaxLeverage = partial
-            ? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-            : this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+        const marketMaxLeverage = this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
         let priceDelta;
         if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
             priceDelta = freeCollateralAfterTrade
@@ -486,7 +477,7 @@ class ClearingHouseUser {
             .neg();
         return this.liquidationPrice({
             marketIndex: positionMarketIndex,
-        }, closeBaseAmount, true);
+        }, closeBaseAmount);
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.

package/lib/config.js

@@ -7,7 +7,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: '9jwr5nC2f9yAraXrg4UzHXmCX3vi9FQkjD6p9e8bRqNa',
+        CLEARING_HOUSE_PROGRAM_ID: '4oyTJnAQ9FqJj1y9mPytbWsLeeHmBzGYfuFqypwyQvuh',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         MARKETS: markets_1.DevnetMarkets,
         BANKS: banks_1.DevnetBanks,