@drift-labs/sdk 0.2.0-master.20 → 0.2.0-master.23

package/lib/addresses/pda.d.ts

@@ -11,3 +11,6 @@ export declare function getMarketPublicKey(programId: PublicKey, marketIndex: BN
 export declare function getBankPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
 export declare function getBankVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
 export declare function getBankVaultAuthorityPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
+export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
+export declare function getInsuranceFundVaultAuthorityPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
+export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, bankIndex: BN): PublicKey;

package/lib/addresses/pda.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
+exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultAuthorityPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
 const anchor = __importStar(require("@project-serum/anchor"));
 async function getClearingHouseStateAccountPublicKeyAndNonce(programId) {
     return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
@@ -88,3 +88,25 @@ async function getBankVaultAuthorityPublicKey(programId, bankIndex) {
     ], programId))[0];
 }
 exports.getBankVaultAuthorityPublicKey = getBankVaultAuthorityPublicKey;
+async function getInsuranceFundVaultPublicKey(programId, bankIndex) {
+    return (await anchor.web3.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
+        bankIndex.toArrayLike(Buffer, 'le', 8),
+    ], programId))[0];
+}
+exports.getInsuranceFundVaultPublicKey = getInsuranceFundVaultPublicKey;
+async function getInsuranceFundVaultAuthorityPublicKey(programId, bankIndex) {
+    return (await anchor.web3.PublicKey.findProgramAddress([
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault_authority')),
+        bankIndex.toArrayLike(Buffer, 'le', 8),
+    ], programId))[0];
+}
+exports.getInsuranceFundVaultAuthorityPublicKey = getInsuranceFundVaultAuthorityPublicKey;
+function getInsuranceFundStakeAccountPublicKey(programId, authority, bankIndex) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
+        authority.toBuffer(),
+        bankIndex.toArrayLike(Buffer, 'le', 8),
+    ], programId)[0];
+}
+exports.getInsuranceFundStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey;

package/lib/admin.d.ts

@@ -20,6 +20,7 @@ export declare class Admin extends ClearingHouse {
     updateCurveUpdateIntensity(marketIndex: BN, curveUpdateIntensity: number): Promise<TransactionSignature>;
     updateMarginRatio(marketIndex: BN, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
     updateMarketBaseSpread(marketIndex: BN, baseSpread: number): Promise<TransactionSignature>;
+    updateAmmJitIntensity(marketIndex: BN, ammJitIntensity: number): Promise<TransactionSignature>;
     updateMarketMaxSpread(marketIndex: BN, maxSpread: number): Promise<TransactionSignature>;
     updatePartialLiquidationClosePercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updatePartialLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
@@ -30,6 +31,8 @@ export declare class Admin extends ClearingHouse {
     updateFee(fees: FeeStructure): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
     updateBankWithdrawGuardThreshold(bankIndex: BN, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    updateBankIfFactor(bankIndex: BN, userIfFactor: BN, totalIfFactor: BN, liquidationIfFactor: BN): Promise<TransactionSignature>;
+    updateBankInsuranceWithdrawEscrowPeriod(bankIndex: BN, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
     updateLpCooldownTime(marketIndex: BN, cooldownTime: BN): Promise<TransactionSignature>;
     updateMarketOracle(marketIndex: BN, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
     updateMarketMinimumQuoteAssetTradeSize(marketIndex: BN, minimumTradeSize: BN): Promise<TransactionSignature>;

package/lib/admin.js

@@ -63,6 +63,8 @@ class Admin extends clearingHouse_1.ClearingHouse {
         const bank = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
         const bankVault = await (0, pda_1.getBankVaultPublicKey)(this.program.programId, bankIndex);
         const bankVaultAuthority = await (0, pda_1.getBankVaultAuthorityPublicKey)(this.program.programId, bankIndex);
+        const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, bankIndex);
+        const insuranceFundVaultAuthority = await (0, pda_1.getInsuranceFundVaultAuthorityPublicKey)(this.program.programId, bankIndex);
         const initializeTx = await this.program.transaction.initializeBank(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
             accounts: {
                 admin: this.wallet.publicKey,
@@ -70,6 +72,8 @@ class Admin extends clearingHouse_1.ClearingHouse {
                 bank,
                 bankVault,
                 bankVaultAuthority,
+                insuranceFundVault,
+                insuranceFundVaultAuthority,
                 bankMint: mint,
                 oracle,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
@@ -260,6 +264,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateAmmJitIntensity(marketIndex, ammJitIntensity) {
+        return await this.program.rpc.updateAmmJitIntensity(ammJitIntensity, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
     async updateMarketMaxSpread(marketIndex, maxSpread) {
         return await this.program.rpc.updateMarketMaxSpread(maxSpread, {
             accounts: {
@@ -342,6 +355,24 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateBankIfFactor(bankIndex, userIfFactor, totalIfFactor, liquidationIfFactor) {
+        return await this.program.rpc.updateBankIfFactor(bankIndex, userIfFactor, totalIfFactor, liquidationIfFactor, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                bank: await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex),
+            },
+        });
+    }
+    async updateBankInsuranceWithdrawEscrowPeriod(bankIndex, insuranceWithdrawEscrowPeriod) {
+        return await this.program.rpc.updateBankInsuranceWithdrawEscrowPeriod(insuranceWithdrawEscrowPeriod, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                bank: await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex),
+            },
+        });
+    }
     async updateLpCooldownTime(marketIndex, cooldownTime) {
         return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
             accounts: {

package/lib/clearingHouse.d.ts

@@ -149,12 +149,12 @@ export declare class ClearingHouse {
     getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, liabilityBankIndex: BN, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
     liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionSignature>;
     getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: BN, assetBankIndex: BN, maxPnlTransfer: BN): Promise<TransactionInstruction>;
-    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionSignature>;
-    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: BN): Promise<TransactionInstruction>;
+    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN, marketIndex: BN): Promise<TransactionSignature>;
+    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN, marketIndex: BN): Promise<TransactionInstruction>;
     resolveBorrowBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionSignature>;
     getResolveBorrowBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, bankIndex: BN): Promise<TransactionInstruction>;
-    getRemainingAccountsForLiquidation(params: {
-        userAccount: UserAccount;
+    getRemainingAccountsWithCounterparty(params: {
+        counterPartyUserAccount: UserAccount;
         writableMarketIndex?: BN;
         writableBankIndexes?: BN[];
     }): AccountMeta[];
@@ -164,4 +164,11 @@ export declare class ClearingHouse {
     getSettleFundingPaymentIx(userAccount: PublicKey): Promise<TransactionInstruction>;
     triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any): void;
     getOracleDataForMarket(marketIndex: BN): OraclePriceData;
+    initializeInsuranceFundStake(bankIndex: BN): Promise<TransactionSignature>;
+    getInitializeInsuranceFundStakeIx(bankIndex: BN): Promise<TransactionInstruction>;
+    addInsuranceFundStake(bankIndex: BN, amount: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    requestRemoveInsuranceFundStake(bankIndex: BN, amount: BN): Promise<TransactionSignature>;
+    cancelRequestRemoveInsuranceFundStake(bankIndex: BN): Promise<TransactionSignature>;
+    removeInsuranceFundStake(bankIndex: BN, collateralAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    settleRevenueToInsuranceFund(bankIndex: BN): Promise<TransactionSignature>;
 }

package/lib/clearingHouse.js

@@ -133,9 +133,13 @@ class ClearingHouse {
      *	Forces the accountSubscriber to fetch account updates from rpc
      */
     async fetchAccounts() {
-        await Promise.all([...this.users.values()]
+        const promises = [...this.users.values()]
             .map((user) => user.fetchAccounts())
-            .concat(this.accountSubscriber.fetch()));
+            .concat(this.accountSubscriber.fetch());
+        if (this.userStats) {
+            promises.concat(this.userStats.fetchAccounts());
+        }
+        await Promise.all(promises);
     }
     async unsubscribe() {
         const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
@@ -1077,7 +1081,9 @@ class ClearingHouse {
         orderParams = this.getOrderParams(orderParams);
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccounts({
+        // todo merge this with getRemainingAccounts
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: takerInfo.takerUserAccount,
             writableMarketIndex: orderParams.marketIndex,
         });
         if (referrerInfo) {
@@ -1216,9 +1222,9 @@ class ClearingHouse {
         const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
         const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             writableMarketIndex: marketIndex,
-            userAccount,
+            counterPartyUserAccount: userAccount,
         });
         return await this.program.instruction.liquidatePerp(marketIndex, maxBaseAssetAmount, {
             accounts: {
@@ -1238,8 +1244,8 @@ class ClearingHouse {
     }
     async getLiquidateBorrowIx(userAccountPublicKey, userAccount, assetBankIndex, liabilityBankIndex, maxLiabilityTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: userAccount,
             writableBankIndexes: [liabilityBankIndex, assetBankIndex],
         });
         return await this.program.instruction.liquidateBorrow(assetBankIndex, liabilityBankIndex, maxLiabilityTransfer, {
@@ -1258,8 +1264,8 @@ class ClearingHouse {
     }
     async getLiquidateBorrowForPerpPnlIx(userAccountPublicKey, userAccount, perpMarketIndex, liabilityBankIndex, maxLiabilityTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: userAccount,
             writableMarketIndex: perpMarketIndex,
             writableBankIndexes: [liabilityBankIndex],
         });
@@ -1279,8 +1285,8 @@ class ClearingHouse {
     }
     async getLiquidatePerpPnlForDepositIx(userAccountPublicKey, userAccount, perpMarketIndex, assetBankIndex, maxPnlTransfer) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
-            userAccount,
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+            counterPartyUserAccount: userAccount,
             writableMarketIndex: perpMarketIndex,
             writableBankIndexes: [assetBankIndex],
         });
@@ -1294,22 +1300,28 @@ 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);
+    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, bankIndex, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, bankIndex, marketIndex)), [], this.opts);
         return txSig;
     }
-    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, bankIndex, marketIndex) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             writableMarketIndex: marketIndex,
-            userAccount,
+            writableBankIndexes: [bankIndex],
+            counterPartyUserAccount: userAccount,
         });
-        return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
+        const bank = this.getBankAccount(bankIndex);
+        return await this.program.instruction.resolvePerpBankruptcy(bankIndex, marketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 liquidator: liquidatorPublicKey,
+                bankVault: bank.vault,
+                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVaultAuthority: bank.insuranceFundVaultAuthority,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
             remainingAccounts: remainingAccounts,
         });
@@ -1320,26 +1332,31 @@ class ClearingHouse {
     }
     async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex) {
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
-        const remainingAccounts = this.getRemainingAccountsForLiquidation({
+        const remainingAccounts = this.getRemainingAccountsWithCounterparty({
             writableBankIndexes: [bankIndex],
-            userAccount,
+            counterPartyUserAccount: userAccount,
         });
+        const bank = this.getBankAccount(bankIndex);
         return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
                 liquidator: liquidatorPublicKey,
+                bankVault: bank.vault,
+                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVaultAuthority: bank.insuranceFundVaultAuthority,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
             remainingAccounts: remainingAccounts,
         });
     }
-    getRemainingAccountsForLiquidation(params) {
-        const liquidateeUserAccount = params.userAccount;
+    getRemainingAccountsWithCounterparty(params) {
+        const counterPartyUserAccount = params.counterPartyUserAccount;
         const oracleAccountMap = new Map();
         const bankAccountMap = new Map();
         const marketAccountMap = new Map();
-        for (const bankBalance of liquidateeUserAccount.bankBalances) {
+        for (const bankBalance of counterPartyUserAccount.bankBalances) {
             if (!bankBalance.balance.eq(numericConstants_1.ZERO)) {
                 const bankAccount = this.getBankAccount(bankBalance.bankIndex);
                 bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
@@ -1356,7 +1373,7 @@ class ClearingHouse {
                 }
             }
         }
-        for (const position of liquidateeUserAccount.positions) {
+        for (const position of counterPartyUserAccount.positions) {
             if (!(0, position_1.positionIsAvailable)(position)) {
                 const market = this.getMarketAccount(position.marketIndex);
                 marketAccountMap.set(position.marketIndex.toNumber(), {
@@ -1511,5 +1528,122 @@ class ClearingHouse {
         const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
         return oracleData;
     }
+    async initializeInsuranceFundStake(bankIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getInitializeInsuranceFundStakeIx(bankIndex)), [], this.opts);
+        return txSig;
+    }
+    async getInitializeInsuranceFundStakeIx(bankIndex) {
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+        return await this.program.instruction.initializeInsuranceFundStake(bankIndex, {
+            accounts: {
+                insuranceFundStake: ifStakeAccountPublicKey,
+                bank: this.getBankAccount(bankIndex).pubkey,
+                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(),
+            },
+        });
+    }
+    async addInsuranceFundStake(bankIndex, amount, collateralAccountPublicKey) {
+        const bank = this.getBankAccount(bankIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        return await this.program.rpc.addInsuranceFundStake(bankIndex, amount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: bank.insuranceFundVault,
+                userTokenAccount: collateralAccountPublicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async requestRemoveInsuranceFundStake(bankIndex, amount) {
+        const bank = this.getBankAccount(bankIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        return await this.program.rpc.requestRemoveInsuranceFundStake(bankIndex, amount, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: bank.insuranceFundVault,
+                // userTokenAccount: collateralAccountPublicKey,
+                // tokenProgram: TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async cancelRequestRemoveInsuranceFundStake(bankIndex) {
+        const bank = this.getBankAccount(bankIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(bankIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: bank.insuranceFundVault,
+                // userTokenAccount: collateralAccountPublicKey,
+                // tokenProgram: TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async removeInsuranceFundStake(bankIndex, collateralAccountPublicKey) {
+        const bank = this.getBankAccount(bankIndex);
+        const ifStakeAccountPublicKey = (0, pda_1.getInsuranceFundStakeAccountPublicKey)(this.program.programId, this.wallet.publicKey, bankIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        return await this.program.rpc.removeInsuranceFundStake(bankIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                insuranceFundStake: ifStakeAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+                insuranceFundVault: bank.insuranceFundVault,
+                insuranceFundVaultAuthority: bank.insuranceFundVaultAuthority,
+                userTokenAccount: collateralAccountPublicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
+    async settleRevenueToInsuranceFund(bankIndex) {
+        const bank = this.getBankAccount(bankIndex);
+        const remainingAccounts = this.getRemainingAccounts({
+            writableBankIndex: bankIndex,
+        });
+        return await this.program.rpc.settleRevenueToInsuranceFund(bankIndex, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                bank: bank.pubkey,
+                bankVault: bank.vault,
+                bankVaultAuthority: bank.vaultAuthority,
+                insuranceFundVault: bank.insuranceFundVault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+            remainingAccounts,
+        });
+    }
 }
 exports.ClearingHouse = ClearingHouse;

package/lib/clearingHouseUser.d.ts

@@ -37,6 +37,7 @@ export declare class ClearingHouseUser {
      */
     getUserPosition(marketIndex: BN): UserPosition | undefined;
     getEmptyPosition(marketIndex: BN): UserPosition;
+    getClonedPosition(position: UserPosition): UserPosition;
     /**
      * @param orderId
      * @returns Order
@@ -53,7 +54,7 @@ export declare class ClearingHouseUser {
      * calculates the market position if the lp position was settled
      * @returns : userPosition
      */
-    getSettledLPPosition(marketIndex: BN): [UserPosition, BN];
+    getSettledLPPosition(marketIndex: BN): [UserPosition, BN, BN];
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
      * @returns : Precision QUOTE_PRECISION
@@ -64,6 +65,13 @@ export declare class ClearingHouseUser {
      * @returns : Precision QUOTE_PRECISION
      */
     getFreeCollateral(): BN;
+    /**
+     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+     */
+    getMarginRequirement(type: MarginCategory): BN;
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
     getInitialMarginRequirement(): BN;
     /**
      * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION

package/lib/clearingHouseUser.js

@@ -78,6 +78,10 @@ class ClearingHouseUser {
             lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
     }
+    getClonedPosition(position) {
+        const clonedPosition = Object.assign({}, position);
+        return clonedPosition;
+    }
     /**
      * @param orderId
      * @returns Order
@@ -104,7 +108,8 @@ class ClearingHouseUser {
      * @returns : userPosition
      */
     getSettledLPPosition(marketIndex) {
-        const position = this.getUserPosition(marketIndex);
+        const _position = this.getUserPosition(marketIndex);
+        const position = this.getClonedPosition(_position);
         const market = this.clearingHouse.getMarketAccount(position.marketIndex);
         const nShares = position.lpShares;
         const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
@@ -180,7 +185,7 @@ class ClearingHouseUser {
         else {
             position.lastCumulativeFundingRate = numericConstants_1.ZERO;
         }
-        return [position, pnl];
+        return [position, remainderBaa, pnl];
     }
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
@@ -201,37 +206,69 @@ class ClearingHouseUser {
         const freeCollateral = totalCollateral.sub(initialMarginRequirement);
         return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
     }
-    getInitialMarginRequirement() {
-        const postionMarginRequirement = this.getUserAccount().positions.reduce((marginRequirement, marketPosition) => {
-            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(marketPosition);
-            const worstCaseAssetValue = worstCaseBaseAssetAmount
-                .abs()
-                .mul(this.getOracleDataForMarket(market.marketIndex).price)
-                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-            const marketMarginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), 'Initial'));
-            return marginRequirement.add(worstCaseAssetValue.mul(marketMarginRatio).div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO);
-        const bankMarginRequirement = this.getBankLiabilityValue(undefined, 'Initial');
-        return bankMarginRequirement.add(postionMarginRequirement);
-    }
     /**
-     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
      */
-    getMaintenanceMarginRequirement() {
+    getMarginRequirement(type) {
         return this.getUserAccount()
             .positions.reduce((marginRequirement, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
+            if (marketPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                // is an lp
+                // clone so we dont mutate the position
+                marketPosition = this.getClonedPosition(marketPosition);
+                // settle position
+                const [settledPosition, dustBaa, _] = this.getSettledLPPosition(market.marketIndex);
+                marketPosition.baseAssetAmount =
+                    settledPosition.baseAssetAmount.add(dustBaa);
+                marketPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+                // open orders
+                let openAsks;
+                if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
+                    openAsks = market.amm.maxBaseAssetReserve
+                        .sub(market.amm.baseAssetReserve)
+                        .mul(marketPosition.lpShares)
+                        .div(market.amm.sqrtK)
+                        .mul(new _1.BN(-1));
+                }
+                else {
+                    openAsks = numericConstants_1.ZERO;
+                }
+                let openBids;
+                if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
+                    openBids = market.amm.baseAssetReserve
+                        .sub(market.amm.minBaseAssetReserve)
+                        .mul(marketPosition.lpShares)
+                        .div(market.amm.sqrtK);
+                }
+                else {
+                    openBids = numericConstants_1.ZERO;
+                }
+                marketPosition.openAsks = marketPosition.openAsks.add(openAsks);
+                marketPosition.openBids = marketPosition.openBids.add(openBids);
+            }
             const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(marketPosition);
             const worstCaseAssetValue = worstCaseBaseAssetAmount
                 .abs()
                 .mul(this.getOracleDataForMarket(market.marketIndex).price)
                 .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
             return marginRequirement.add(worstCaseAssetValue
-                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), 'Maintenance')))
+                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), type)))
                 .div(numericConstants_1.MARGIN_PRECISION));
         }, numericConstants_1.ZERO)
-            .add(this.getBankLiabilityValue(undefined, 'Maintenance'));
+            .add(this.getBankLiabilityValue(undefined, type));
+    }
+    /**
+     * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getInitialMarginRequirement() {
+        return this.getMarginRequirement('Initial');
+    }
+    /**
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+     */
+    getMaintenanceMarginRequirement() {
+        return this.getMarginRequirement('Maintenance');
     }
     /**
      * calculates unrealized position price pnl
@@ -326,7 +363,7 @@ class ClearingHouseUser {
     getTotalPositionValue() {
         return this.getUserAccount().positions.reduce((positionValue, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            const posVal = (0, margin_1.calculateMarginBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex));
+            const posVal = (0, margin_1.calculateBaseAssetValueWithOracle)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex));
             return positionValue.add(posVal);
         }, numericConstants_1.ZERO);
     }
@@ -337,7 +374,7 @@ class ClearingHouseUser {
     getPositionValue(marketIndex, oraclePriceData) {
         const userPosition = this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
         const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
-        return (0, margin_1.calculateMarginBaseAssetValue)(market, userPosition, oraclePriceData);
+        return (0, margin_1.calculateBaseAssetValueWithOracle)(market, userPosition, oraclePriceData);
     }
     getPositionSide(currentPosition) {
         if (currentPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
@@ -374,7 +411,7 @@ class ClearingHouseUser {
             baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
         }
         else {
-            baseAssetValue = (0, margin_1.calculateMarginBaseAssetValue)(market, position, oraclePriceData);
+            baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, oraclePriceData);
         }
         if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
             return [numericConstants_1.ZERO, numericConstants_1.ZERO];
@@ -496,13 +533,13 @@ class ClearingHouseUser {
         if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
             return new _1.BN(-1);
         const market = this.clearingHouse.getMarketAccount(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValue = (0, margin_1.calculateMarginBaseAssetValue)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
+        const proposedMarketPositionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
         // total position value after trade
         const totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
         const marginRequirementExcludingTargetMarket = this.getUserAccount().positions.reduce((totalMarginRequirement, position) => {
             if (!position.marketIndex.eq(marketPosition.marketIndex)) {
                 const market = this.clearingHouse.getMarketAccount(position.marketIndex);
-                const positionValue = (0, margin_1.calculateMarginBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
+                const positionValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, position, this.getOracleDataForMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
                     .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')))
                     .div(numericConstants_1.MARGIN_PRECISION);

package/lib/config.js

@@ -7,7 +7,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: '65sz7dRiWDRPZjiRxcTxPM7AE6VK4Nag9HEK6oBJXhJn',
+        CLEARING_HOUSE_PROGRAM_ID: 'AXmmKr4MHipFp4SDr6CTUBzJtD1rZPHTzPDVPJ6L6r64',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         MARKETS: markets_1.DevnetMarkets,
         BANKS: banks_1.DevnetBanks,

package/lib/constants/banks.d.ts

@@ -7,6 +7,8 @@ export declare type BankConfig = {
     oracle: PublicKey;
     mint: PublicKey;
     oracleSource: OracleSource;
+    precision: BN;
+    precisionExp: BN;
 };
 export declare const WRAPPED_SOL_MINT: PublicKey;
 export declare const DevnetBanks: BankConfig[];