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

package/src/clearingHouse.ts

@@ -11,6 +11,10 @@ import {
 	BankAccount,
 	UserBankBalance,
 	MakerInfo,
+	TakerInfo,
+	OptionalOrderParams,
+	DefaultOrderParams,
+	OrderType,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -25,7 +29,7 @@ import {
 	AccountMeta,
 } from '@solana/web3.js';
 
-import { MockUSDCFaucet } from './mockUSDCFaucet';
+import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
@@ -52,7 +56,6 @@ import { WebSocketClearingHouseAccountSubscriber } from './accounts/webSocketCle
 import { RetryTxSender } from './tx/retryTxSender';
 import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
-import { getMarketOrderParams } from './orderParams';
 import { getMarketsBanksAndOraclesForSubscription } from './config';
 
 /**
@@ -561,13 +564,19 @@ export class ClearingHouse {
 				writableBankIndex: bankIndex,
 			});
 		} else {
-			remainingAccounts = [
-				{
-					pubkey: this.getBankAccount(bankIndex).pubkey,
+			const bankAccount = this.getBankAccount(bankIndex);
+			if (!bankAccount.oracle.equals(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);
@@ -635,11 +644,12 @@ export class ClearingHouse {
 	public async initializeUserAccountForDevnet(
 		userId = 0,
 		name = DEFAULT_USER_NAME,
-		mockUSDCFaucet: MockUSDCFaucet,
+		bankIndex: BN,
+		tokenFaucet: TokenFaucet,
 		amount: BN
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] =
-			await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(
+			await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(
 				this.wallet.publicKey,
 				amount
 			);
@@ -649,7 +659,7 @@ export class ClearingHouse {
 
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
-			new BN(0),
+			bankIndex,
 			associateTokenPublicKey,
 			userId,
 			false,
@@ -798,20 +808,17 @@ export class ClearingHouse {
 		marketIndex: BN,
 		limitPrice?: BN
 	): Promise<TransactionSignature> {
-		return await this.placeAndTake(
-			getMarketOrderParams(
-				marketIndex,
-				direction,
-				ZERO,
-				amount,
-				false,
-				limitPrice
-			)
-		);
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction,
+			baseAssetAmount: amount,
+			price: limitPrice,
+		});
 	}
 
 	public async placeOrder(
-		orderParams: OrderParams
+		orderParams: OptionalOrderParams
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
 			wrapInTx(await this.getPlaceOrderIx(orderParams)),
@@ -822,14 +829,16 @@ export class ClearingHouse {
 		return txSig;
 	}
 
+	getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams {
+		return Object.assign({}, DefaultOrderParams, optionalOrderParams);
+	}
+
 	public async getPlaceOrderIx(
-		orderParams: OrderParams
+		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-			.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({
 			writableMarketIndex: orderParams.marketIndex,
 		});
@@ -839,38 +848,11 @@ export class ClearingHouse {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle: priceOracle,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async expireOrders(
-		userAccountPublicKey: PublicKey
-	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getExpireOrdersIx(userAccountPublicKey)),
-			[],
-			this.opts
-		);
-		return txSig;
-	}
-
-	public async getExpireOrdersIx(
-		userAccountPublicKey: PublicKey
-	): Promise<TransactionInstruction> {
-		const fillerPublicKey = await this.getUserAccountPublicKey();
-
-		return await this.program.instruction.expireOrders({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				filler: fillerPublicKey,
-				user: userAccountPublicKey,
-				authority: this.wallet.publicKey,
-			},
-		});
-	}
-
 	public async updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getUpdateAMMsIx(marketIndexes)),
@@ -914,7 +896,7 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrder(orderId: BN): Promise<TransactionSignature> {
+	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getCancelOrderIx(orderId)),
 			[],
@@ -923,20 +905,16 @@ export class ClearingHouse {
 		return txSig;
 	}
 
-	public async getCancelOrderIx(orderId: BN): Promise<TransactionInstruction> {
+	public async getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const order = this.getOrder(orderId);
-		const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({});
 
-		return await this.program.instruction.cancelOrder(orderId, {
+		return await this.program.instruction.cancelOrder(orderId ?? null, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle,
 			},
 			remainingAccounts,
 		});
@@ -974,36 +952,107 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelAllOrders(
-		bestEffort?: boolean
+	public async fillOrder(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		order?: Order,
+		makerInfo?: MakerInfo
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getCancelAllOrdersIx(bestEffort)),
+			wrapInTx(
+				await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getCancelAllOrdersIx(
-		bestEffort?: boolean
+	public async getFillOrderIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		order: Order,
+		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const fillerPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccounts({});
+		const marketIndex = order.marketIndex;
+		const marketAccount = this.getMarketAccount(marketIndex);
+
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
 
-		for (const order of this.getUserAccount().orders) {
-			const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+		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(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
+		for (const position of userAccount.positions) {
+			if (
+				!positionIsAvailable(position) &&
+				!position.marketIndex.eq(order.marketIndex)
+			) {
+				const market = this.getMarketAccount(position.marketIndex);
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: true,
+					isSigner: false,
+				});
+				oracleAccountMap.set(market.amm.oracle.toString(), {
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+
+		const remainingAccounts = [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
+
+		if (makerInfo) {
 			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
+				pubkey: makerInfo.maker,
+				isWritable: true,
 				isSigner: false,
 			});
 		}
 
-		return await this.program.instruction.cancelAllOrders(bestEffort, {
+		const orderId = order.orderId;
+		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+
+		return await this.program.instruction.fillOrder(orderId, makerOrderId, {
 			accounts: {
 				state: await this.getStatePublicKey(),
+				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
 			},
@@ -1011,153 +1060,102 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrdersByMarketAndSide(
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
-	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getCancelOrdersByMarketAndSideIx(
-					bestEffort,
-					marketIndexOnly,
-					directionOnly
-				)
-			),
-			[],
-			this.opts
-		);
-		return txSig;
-	}
-
-	public async getCancelOrdersByMarketAndSideIx(
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
-	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-
-		const remainingAccounts = this.getRemainingAccounts({});
-
-		for (const order of this.getUserAccount().orders) {
-			const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
-
-		return await this.program.instruction.cancelOrdersByMarketAndSide(
-			bestEffort,
-			marketIndexOnly,
-			directionOnly,
-			{
-				accounts: {
-					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
-					authority: this.wallet.publicKey,
-				},
-				remainingAccounts,
-			}
-		);
-	}
-
-	public async fillOrder(
+	public async triggerOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
-		order: Order,
-		makerInfo?: MakerInfo
+		order: Order
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)
-			),
+			wrapInTx(await this.getTriggerOrderIx(userAccountPublicKey, user, order)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getFillOrderIx(
+	public async getTriggerOrderIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
-		order: Order,
-		makerInfo?: MakerInfo
+		order: Order
 	): Promise<TransactionInstruction> {
 		const fillerPublicKey = await this.getUserAccountPublicKey();
 
 		const marketIndex = order.marketIndex;
 		const marketAccount = this.getMarketAccount(marketIndex);
-		const oracle = marketAccount.amm.oracle;
 
-		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<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
+
+		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(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
 		for (const position of userAccount.positions) {
 			if (
 				!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)
-		);
 
-		if (makerInfo) {
-			remainingAccounts.push({
-				pubkey: makerInfo.maker,
-				isWritable: true,
-				isSigner: false,
-			});
-		}
+		const remainingAccounts = [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
 
 		const orderId = order.orderId;
-		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
-		return await this.program.instruction.fillOrder(orderId, makerOrderId, {
+		return await this.program.instruction.triggerOrder(orderId, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle: oracle,
 			},
 			remainingAccounts,
 		});
 	}
 
 	public async placeAndTake(
-		orderParams: OrderParams,
+		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
@@ -1170,14 +1168,12 @@ export class ClearingHouse {
 	}
 
 	public async getPlaceAndTakeIx(
-		orderParams: OrderParams,
+		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-			.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({
 			writableMarketIndex: orderParams.marketIndex,
 			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
@@ -1201,7 +1197,55 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
 					authority: this.wallet.publicKey,
-					oracle: priceOracle,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async placeAndMake(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getPlaceAndMakeIx(orderParams, takerInfo)),
+			[],
+			this.opts
+		);
+
+		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+
+		return txSig;
+	}
+
+	public async getPlaceAndMakeIx(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: orderParams.marketIndex,
+			writableBankIndex: 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,
 			}
@@ -1219,16 +1263,13 @@ export class ClearingHouse {
 			throw Error(`No position in market ${marketIndex.toString()}`);
 		}
 
-		return await this.placeAndTake(
-			getMarketOrderParams(
-				marketIndex,
-				findDirectionToClose(userPosition),
-				ZERO,
-				userPosition.baseAssetAmount,
-				true,
-				undefined
-			)
-		);
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction: findDirectionToClose(userPosition),
+			baseAssetAmount: userPosition.baseAssetAmount,
+			reduceOnly: true,
+		});
 	}
 
 	public async settlePNLs(
@@ -1350,72 +1391,359 @@ export class ClearingHouse {
 		});
 	}
 
-	public async liquidate(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async liquidatePerp(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN,
+		maxBaseAssetAmount: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getLiquidateIx(liquidateeUserAccountPublicKey)),
+			wrapInTx(
+				await this.getLiquidatePerpIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex,
+					maxBaseAssetAmount
+				)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getLiquidateIx(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async getLiquidatePerpIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN,
+		maxBaseAssetAmount: BN
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const liquidateeUserAccount = (await this.program.account.user.fetch(
-			liquidateeUserAccountPublicKey
-		)) as UserAccount;
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			writableMarketIndex: marketIndex,
+			userAccount,
+		});
 
-		const bankAccountInfos = [
+		return await this.program.instruction.liquidatePerp(
+			marketIndex,
+			maxBaseAssetAmount,
 			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [];
-		const oracleAccountInfos = [];
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidateBorrow(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetBankIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowIx(
+					userAccountPublicKey,
+					userAccount,
+					assetBankIndex,
+					liabilityBankIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetBankIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionInstruction> {
+		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,
+			}
+		);
+	}
+
+	public async liquidateBorrowForPerpPnl(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowForPerpPnlIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					liabilityBankIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowForPerpPnlIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionInstruction> {
+		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,
+			}
+		);
+	}
+
+	public async liquidatePerpPnlForDeposit(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		assetBankIndex: BN,
+		maxPnlTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidatePerpPnlForDepositIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					assetBankIndex,
+					maxPnlTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidatePerpPnlForDepositIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		assetBankIndex: BN,
+		maxPnlTransfer: BN
+	): Promise<TransactionInstruction> {
+		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: {
+		userAccount: UserAccount;
+		writableMarketIndex?: BN;
+		writableBankIndexes?: BN[];
+	}): AccountMeta[] {
+		const liquidateeUserAccount = params.userAccount;
+
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
+		for (const bankBalance of liquidateeUserAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
 		for (const position of liquidateeUserAccount.positions) {
 			if (!positionIsAvailable(position)) {
 				const market = this.getMarketAccount(position.marketIndex);
-				const marketPublicKey = await 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: 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(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+		for (const position of userAccount.positions) {
+			if (!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(PublicKey.default)) {
+					oracleAccountMap.set(bank.oracle.toString(), {
+						pubkey: bank.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
+		return [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
 	}
 
 	public async updateFundingRate(