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

package/lib/index.d.ts

@@ -40,6 +40,7 @@ export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
 export * from './math/margin';
+export * from './math/insurance';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';

package/lib/index.js

@@ -63,6 +63,7 @@ __exportStar(require("./math/trade"), exports);
 __exportStar(require("./math/orders"), exports);
 __exportStar(require("./math/repeg"), exports);
 __exportStar(require("./math/margin"), exports);
+__exportStar(require("./math/insurance"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);
 __exportStar(require("./wallet"), exports);

package/lib/math/insurance.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '../index';
+export declare function stakeAmountToShares(amount: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;
+export declare function unstakeSharesToAmount(nShares: BN, totalIfShares: BN, insuranceFundVaultBalance: BN): BN;

package/lib/math/insurance.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unstakeSharesToAmount = exports.stakeAmountToShares = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+function stakeAmountToShares(amount, totalIfShares, insuranceFundVaultBalance) {
+    let nShares;
+    if (insuranceFundVaultBalance.gt(numericConstants_1.ZERO)) {
+        nShares = amount.mul(totalIfShares).div(insuranceFundVaultBalance);
+    }
+    else {
+        nShares = amount;
+    }
+    return nShares;
+}
+exports.stakeAmountToShares = stakeAmountToShares;
+function unstakeSharesToAmount(nShares, totalIfShares, insuranceFundVaultBalance) {
+    let amount;
+    if (totalIfShares.gt(numericConstants_1.ZERO)) {
+        amount = index_1.BN.max(numericConstants_1.ZERO, nShares.mul(insuranceFundVaultBalance).div(totalIfShares).sub(numericConstants_1.ONE));
+    }
+    else {
+        amount = numericConstants_1.ZERO;
+    }
+    return amount;
+}
+exports.unstakeSharesToAmount = unstakeSharesToAmount;

package/lib/math/margin.d.ts

@@ -7,5 +7,5 @@ imfFactor: BN, liabilityWeight: BN, precision: BN): BN;
 export declare function calculateSizeDiscountAssetWeight(size: BN, // AMM_RESERVE_PRECISION
 imfFactor: BN, assetWeight: BN): BN;
 export declare function calculateOraclePriceForPerpMargin(marketPosition: UserPosition, market: MarketAccount, oraclePriceData: OraclePriceData): BN;
-export declare function calculateMarginBaseAssetValue(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBaseAssetValueWithOracle(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
 export declare function calculateWorstCaseBaseAssetAmount(marketPosition: UserPosition): BN;

package/lib/math/margin.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateWorstCaseBaseAssetAmount = exports.calculateMarginBaseAssetValue = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithOracle = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
 const utils_1 = require("./utils");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
@@ -50,15 +50,13 @@ function calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceDa
     return marginPrice;
 }
 exports.calculateOraclePriceForPerpMargin = calculateOraclePriceForPerpMargin;
-function calculateMarginBaseAssetValue(market, marketPosition, oraclePriceData) {
-    const marginPrice = calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceData);
-    const baseAssetValue = marketPosition.baseAssetAmount
+function calculateBaseAssetValueWithOracle(market, marketPosition, oraclePriceData) {
+    return marketPosition.baseAssetAmount
         .abs()
-        .mul(marginPrice)
+        .mul(oraclePriceData.price)
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-    return baseAssetValue;
 }
-exports.calculateMarginBaseAssetValue = calculateMarginBaseAssetValue;
+exports.calculateBaseAssetValueWithOracle = calculateBaseAssetValueWithOracle;
 function calculateWorstCaseBaseAssetAmount(marketPosition) {
     const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
     const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);

package/lib/math/position.js

@@ -61,7 +61,7 @@ function calculatePositionPNL(market, marketPosition, withFunding = false, oracl
     if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return marketPosition.quoteAssetAmount;
     }
-    const baseAssetValue = (0, margin_1.calculateMarginBaseAssetValue)(market, marketPosition, oraclePriceData);
+    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, marketPosition, oraclePriceData);
     const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
         ? new __1.BN(-1)
         : new __1.BN(1);

package/lib/types.d.ts

@@ -104,9 +104,6 @@ export declare class OrderActionExplanation {
     static readonly NONE: {
         none: {};
     };
-    static readonly BREACHED_MARGIN_REQUIREMENT: {
-        breachedMarginRequirement: {};
-    };
     static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE: {
         oraclePriceBreachedLimitPrice: {};
     };
@@ -183,10 +180,15 @@ export declare type FundingRateRecord = {
     recordId: BN;
     marketIndex: BN;
     fundingRate: BN;
+    fundingRateLong: BN;
+    fundingRateShort: BN;
     cumulativeFundingRateLong: BN;
     cumulativeFundingRateShort: BN;
     oraclePriceTwap: BN;
     markPriceTwap: BN;
+    periodRevenue: BN;
+    netBaseAssetAmount: BN;
+    netUnsettledLpBaseAssetAmount: BN;
 };
 export declare type FundingPaymentRecord = {
     ts: BN;
@@ -294,27 +296,40 @@ export declare type SettlePnlRecord = {
 };
 export declare type OrderRecord = {
     ts: BN;
-    taker: PublicKey;
-    maker: PublicKey;
-    takerOrder: Order;
-    makerOrder: Order;
-    takerPnl: BN;
-    makerPnl: BN;
+    user: PublicKey;
+    order: Order;
+};
+export declare type OrderActionRecord = {
+    ts: BN;
     action: OrderAction;
     actionExplanation: OrderActionExplanation;
-    filler: PublicKey;
-    fillRecordId: BN;
     marketIndex: BN;
-    baseAssetAmountFilled: BN;
-    quoteAssetAmountFilled: BN;
-    makerRebate: BN;
-    takerFee: BN;
-    fillerReward: BN;
-    quoteAssetAmountSurplus: BN;
+    filler: PublicKey | null;
+    fillerReward: BN | null;
+    fillRecordId: BN | null;
+    referrer: PublicKey | null;
+    baseAssetAmountFilled: BN | null;
+    quoteAssetAmountFilled: BN | null;
+    takerPnl: BN | null;
+    makerPnl: BN | null;
+    takerFee: BN | null;
+    makerRebate: BN | null;
+    referrerReward: BN | null;
+    refereeDiscount: BN | null;
+    quoteAssetAmountSurplus: BN | null;
+    taker: PublicKey | null;
+    takerOrderId: BN | null;
+    takerOrderBaseAssetAmount: BN | null;
+    takerOrderBaseAssetAmountFilled: BN | null;
+    takerOrderQuoteAssetAmountFilled: BN | null;
+    takerOrderFee: BN | null;
+    maker: PublicKey | null;
+    makerOrderId: BN | null;
+    makerOrderBaseAssetAmount: BN | null;
+    makerOrderBaseAssetAmountFilled: BN | null;
+    makerOrderQuoteAssetAmountFilled: BN | null;
+    makerOrderFee: BN | null;
     oraclePrice: BN;
-    referrer: PublicKey;
-    referrerReward: BN;
-    refereeDiscount: BN;
 };
 export declare type StateAccount = {
     admin: PublicKey;
@@ -374,6 +389,16 @@ export declare type BankAccount = {
     vault: PublicKey;
     vaultAuthority: PublicKey;
     vaultAuthorityNonce: number;
+    insuranceFundVault: PublicKey;
+    insuranceFundVaultAuthority: PublicKey;
+    insuranceFundVaultAuthorityNonce: number;
+    insuranceWithdrawEscrowPeriod: BN;
+    revenuePool: PoolBalance;
+    totalIfShares: BN;
+    userIfShares: BN;
+    userIfFactor: BN;
+    totalIfFactor: BN;
+    liquidationIfFactor: BN;
     decimals: number;
     optimalUtilization: BN;
     optimalBorrowRate: BN;
@@ -453,6 +478,7 @@ export declare type AMM = {
     maxSpread: number;
     marketPosition: UserPosition;
     marketPositionPerLp: UserPosition;
+    ammJitIntensity: number;
     maxBaseAssetReserve: BN;
     minBaseAssetReserve: BN;
 };
@@ -489,6 +515,7 @@ export declare type UserStatsAccount = {
     isReferrer: boolean;
     totalReferrerReward: BN;
     authority: PublicKey;
+    quoteAssetInsuranceFundStake: BN;
 };
 export declare type UserAccount = {
     authority: PublicKey;
@@ -665,3 +692,12 @@ export declare type OrderFillerRewardStructure = {
     timeBasedRewardLowerBound: BN;
 };
 export declare type MarginCategory = 'Initial' | 'Maintenance';
+export declare type InsuranceFundStake = {
+    bankIndex: BN;
+    authority: PublicKey;
+    ifShares: BN;
+    ifBase: BN;
+    lastWithdrawRequestShares: BN;
+    lastWithdrawRequestValue: BN;
+    lastWithdrawRequestTs: BN;
+};

package/lib/types.js

@@ -61,9 +61,6 @@ class OrderActionExplanation {
 }
 exports.OrderActionExplanation = OrderActionExplanation;
 OrderActionExplanation.NONE = { none: {} };
-OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
-    breachedMarginRequirement: {},
-};
 OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
     oraclePriceBreachedLimitPrice: {},
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.22",
+	"version": "0.2.0-master.23",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/addresses/pda.ts

@@ -129,3 +129,50 @@ export async function getBankVaultAuthorityPublicKey(
 		)
 	)[0];
 }
+
+export async function getInsuranceFundVaultPublicKey(
+	programId: PublicKey,
+	bankIndex: BN
+): Promise<PublicKey> {
+	return (
+		await anchor.web3.PublicKey.findProgramAddress(
+			[
+				Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
+				bankIndex.toArrayLike(Buffer, 'le', 8),
+			],
+			programId
+		)
+	)[0];
+}
+
+export async function getInsuranceFundVaultAuthorityPublicKey(
+	programId: PublicKey,
+	bankIndex: BN
+): Promise<PublicKey> {
+	return (
+		await anchor.web3.PublicKey.findProgramAddress(
+			[
+				Buffer.from(
+					anchor.utils.bytes.utf8.encode('insurance_fund_vault_authority')
+				),
+				bankIndex.toArrayLike(Buffer, 'le', 8),
+			],
+			programId
+		)
+	)[0];
+}
+
+export function getInsuranceFundStakeAccountPublicKey(
+	programId: PublicKey,
+	authority: PublicKey,
+	bankIndex: BN
+): PublicKey {
+	return anchor.web3.PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
+			authority.toBuffer(),
+			bankIndex.toArrayLike(Buffer, 'le', 8),
+		],
+		programId
+	)[0];
+}

package/src/admin.ts

@@ -17,6 +17,8 @@ import {
 	getBankPublicKey,
 	getBankVaultPublicKey,
 	getMarketPublicKey,
+	getInsuranceFundVaultPublicKey,
+	getInsuranceFundVaultAuthorityPublicKey,
 } from './addresses/pda';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
@@ -102,6 +104,17 @@ export class Admin extends ClearingHouse {
 			bankIndex
 		);
 
+		const insuranceFundVault = await getInsuranceFundVaultPublicKey(
+			this.program.programId,
+			bankIndex
+		);
+
+		const insuranceFundVaultAuthority =
+			await getInsuranceFundVaultAuthorityPublicKey(
+				this.program.programId,
+				bankIndex
+			);
+
 		const initializeTx = await this.program.transaction.initializeBank(
 			optimalUtilization,
 			optimalRate,
@@ -120,6 +133,8 @@ export class Admin extends ClearingHouse {
 					bank,
 					bankVault,
 					bankVaultAuthority,
+					insuranceFundVault,
+					insuranceFundVaultAuthority,
 					bankMint: mint,
 					oracle,
 					rent: SYSVAR_RENT_PUBKEY,
@@ -452,6 +467,19 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateAmmJitIntensity(
+		marketIndex: BN,
+		ammJitIntensity: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateAmmJitIntensity(ammJitIntensity, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
 	public async updateMarketMaxSpread(
 		marketIndex: BN,
 		maxSpread: number
@@ -591,6 +619,43 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
+	public async updateBankIfFactor(
+		bankIndex: BN,
+		userIfFactor: BN,
+		totalIfFactor: BN,
+		liquidationIfFactor: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateBankIfFactor(
+			bankIndex,
+			userIfFactor,
+			totalIfFactor,
+			liquidationIfFactor,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					bank: await getBankPublicKey(this.program.programId, bankIndex),
+				},
+			}
+		);
+	}
+
+	public async updateBankInsuranceWithdrawEscrowPeriod(
+		bankIndex: BN,
+		insuranceWithdrawEscrowPeriod: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateBankInsuranceWithdrawEscrowPeriod(
+			insuranceWithdrawEscrowPeriod,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					bank: await getBankPublicKey(this.program.programId, bankIndex),
+				},
+			}
+		);
+	}
+
 	public async updateLpCooldownTime(
 		marketIndex: BN,
 		cooldownTime: BN

package/src/clearingHouse.ts

@@ -40,6 +40,7 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
 	getClearingHouseStateAccountPublicKey,
+	getInsuranceFundStakeAccountPublicKey,
 	getMarketPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
@@ -2175,6 +2176,7 @@ export class ClearingHouse {
 	public async resolvePerpBankruptcy(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
+		bankIndex: BN,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
@@ -2182,6 +2184,7 @@ export class ClearingHouse {
 				await this.getResolvePerpBankruptcyIx(
 					userAccountPublicKey,
 					userAccount,
+					bankIndex,
 					marketIndex
 				)
 			),
@@ -2194,24 +2197,36 @@ export class ClearingHouse {
 	public async getResolvePerpBankruptcyIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
+		bankIndex: BN,
 		marketIndex: BN
 	): Promise<TransactionInstruction> {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
 			writableMarketIndex: marketIndex,
+			writableBankIndexes: [bankIndex],
 			counterPartyUserAccount: userAccount,
 		});
 
-		return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				authority: this.wallet.publicKey,
-				user: userAccountPublicKey,
-				liquidator: liquidatorPublicKey,
-			},
-			remainingAccounts: remainingAccounts,
-		});
+		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: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
 	}
 
 	public async resolveBorrowBankruptcy(
@@ -2245,12 +2260,18 @@ export class ClearingHouse {
 			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: TOKEN_PROGRAM_ID,
 			},
 			remainingAccounts: remainingAccounts,
 		});
@@ -2480,4 +2501,191 @@ export class ClearingHouse {
 
 		return oracleData;
 	}
+
+	public async initializeInsuranceFundStake(
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getInitializeInsuranceFundStakeIx(bankIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getInitializeInsuranceFundStakeIx(
+		bankIndex: BN
+	): Promise<TransactionInstruction> {
+		const ifStakeAccountPublicKey = 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(),
+				},
+			}
+		);
+	}
+
+	public async addInsuranceFundStake(
+		bankIndex: BN,
+		amount: BN,
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = 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: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async requestRemoveInsuranceFundStake(
+		bankIndex: BN,
+		amount: BN
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = 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,
+			}
+		);
+	}
+
+	public async cancelRequestRemoveInsuranceFundStake(
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = 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,
+			}
+		);
+	}
+
+	public async removeInsuranceFundStake(
+		bankIndex: BN,
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = 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: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async settleRevenueToInsuranceFund(
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		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: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
 }