@drift-labs/sdk 0.2.0-master.30 → 0.2.0-master.31

package/src/clearingHouse.ts

@@ -23,6 +23,7 @@ import {
 	ReferrerInfo,
 	MarketType,
 	SerumV3FulfillmentConfigAccount,
+	isVariant,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -63,11 +64,7 @@ import {
 } from './accounts/types';
 import { TxSender } from './tx/types';
 import { wrapInTx } from './tx/utils';
-import {
-	ONE,
-	QUOTE_SPOT_MARKET_INDEX,
-	ZERO,
-} from './constants/numericConstants';
+import { QUOTE_SPOT_MARKET_INDEX } from './constants/numericConstants';
 import { findDirectionToClose, positionIsAvailable } from './math/position';
 import { getTokenAmount } from './math/spotBalance';
 import { DEFAULT_USER_NAME, encodeName } from './userName';
@@ -83,6 +80,15 @@ import { WRAPPED_SOL_MINT } from './constants/spotMarkets';
 import { ClearingHouseUserStats } from './clearingHouseUserStats';
 import { isSpotPositionAvailable } from './math/spotPosition';
 
+type RemainingAccountParams = {
+	userAccounts: UserAccount[];
+	writablePerpMarketIndexes?: number[];
+	writableSpotMarketIndexes?: number[];
+	readablePerpMarketIndex?: number;
+	readableSpotMarketIndex?: number;
+	useMarketLastSlotCache?: boolean;
+};
+
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -440,6 +446,21 @@ export class ClearingHouse {
 			});
 		}
 
+		const state = this.getStateAccount();
+		if (!state.whitelistMint.equals(PublicKey.default)) {
+			const associatedTokenPublicKey = await Token.getAssociatedTokenAddress(
+				ASSOCIATED_TOKEN_PROGRAM_ID,
+				TOKEN_PROGRAM_ID,
+				state.whitelistMint,
+				this.wallet.publicKey
+			);
+			remainingAccounts.push({
+				pubkey: associatedTokenPublicKey,
+				isWritable: false,
+				isSigner: false,
+			});
+		}
+
 		const nameBuffer = encodeName(name);
 		const initializeUserAccountIx =
 			await this.program.instruction.initializeUser(userId, nameBuffer, {
@@ -530,6 +551,28 @@ export class ClearingHouse {
 		);
 	}
 
+	public async deleteUser(userId = 0): Promise<TransactionSignature> {
+		const userAccountPublicKey = getUserAccountPublicKeySync(
+			this.program.programId,
+			this.wallet.publicKey,
+			userId
+		);
+
+		const txSig = await this.program.rpc.deleteUser({
+			accounts: {
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+			},
+		});
+
+		await this.users.get(userId)?.unsubscribe();
+		this.users.delete(userId);
+
+		return txSig;
+	}
+
 	public getUser(userId?: number): ClearingHouseUser {
 		userId = userId ?? this.activeUserId;
 		if (!this.users.has(userId)) {
@@ -589,57 +632,30 @@ export class ClearingHouse {
 		);
 	}
 
-	getRemainingAccounts(params: {
-		writablePerpMarketIndex?: number;
-		writableSpotMarketIndex?: number;
-		readablePerpMarketIndex?: number;
-		readableSpotMarketIndex?: number;
-	}): AccountMeta[] {
-		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;
-
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		const perpMarketAccountMap = new Map<number, AccountMeta>();
-		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.getPerpMarketAccount(marketIndexNum);
-				perpMarketAccountMap.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);
-			}
-		}
+	getRemainingAccounts(params: RemainingAccountParams): AccountMeta[] {
+		const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } =
+			this.getRemainingAccountMapsForUsers(params.userAccounts);
 
-		for (const position of userAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				const marketAccount = this.getPerpMarketAccount(position.marketIndex);
-				perpMarketAccountMap.set(position.marketIndex, {
-					pubkey: marketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-				oracleAccountMap.set(marketAccount.pubkey.toString(), {
-					pubkey: marketAccount.amm.oracle,
-					isSigner: false,
-					isWritable: false,
-				});
+		if (params.useMarketLastSlotCache) {
+			const lastUserPositionsSlot = this.getUserAccountAndSlot()?.slot;
+			for (const [marketIndex, 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.getPerpMarketAccount(marketIndex);
+					perpMarketAccountMap.set(marketIndex, {
+						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(marketIndex);
+				}
 			}
 		}
 
@@ -659,39 +675,21 @@ export class ClearingHouse {
 			});
 		}
 
-		if (params.writablePerpMarketIndex !== undefined) {
-			const marketAccount = this.getPerpMarketAccount(
-				params.writablePerpMarketIndex
-			);
-			perpMarketAccountMap.set(params.writablePerpMarketIndex, {
-				pubkey: marketAccount.pubkey,
-				isSigner: false,
-				isWritable: true,
-			});
-			oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-				pubkey: marketAccount.amm.oracle,
-				isSigner: false,
-				isWritable: false,
-			});
-		}
-
-		for (const spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					spotPosition.marketIndex
+		if (params.writablePerpMarketIndexes !== undefined) {
+			for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+				const marketAccount = this.getPerpMarketAccount(
+					writablePerpMarketIndex
 				);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
+				perpMarketAccountMap.set(writablePerpMarketIndex, {
+					pubkey: marketAccount.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+				oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+					pubkey: marketAccount.amm.oracle,
 					isSigner: false,
 					isWritable: false,
 				});
-				if (spotMarketAccount.marketIndex !== 0) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
 			}
 		}
 
@@ -713,21 +711,23 @@ export class ClearingHouse {
 			}
 		}
 
-		if (params.writableSpotMarketIndex !== undefined) {
-			const spotMarketAccount = this.getSpotMarketAccount(
-				params.writableSpotMarketIndex
-			);
-			spotMarketAccountMap.set(params.writableSpotMarketIndex, {
-				pubkey: spotMarketAccount.pubkey,
-				isSigner: false,
-				isWritable: true,
-			});
-			if (spotMarketAccount.marketIndex !== 0) {
-				oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-					pubkey: spotMarketAccount.oracle,
+		if (params.writableSpotMarketIndexes !== undefined) {
+			for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
+				const spotMarketAccount = this.getSpotMarketAccount(
+					writableSpotMarketIndex
+				);
+				spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
+					pubkey: spotMarketAccount.pubkey,
 					isSigner: false,
-					isWritable: false,
+					isWritable: true,
 				});
+				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+						pubkey: spotMarketAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
 			}
 		}
 
@@ -738,10 +738,63 @@ export class ClearingHouse {
 		];
 	}
 
-	public getOrder(orderId: BN | number): Order | undefined {
-		const orderIdBN = orderId instanceof BN ? orderId : new BN(orderId);
-		return this.getUserAccount()?.orders.find((order) =>
-			order.orderId.eq(orderIdBN)
+	getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
+		oracleAccountMap: Map<string, AccountMeta>;
+		spotMarketAccountMap: Map<number, AccountMeta>;
+		perpMarketAccountMap: Map<number, AccountMeta>;
+	} {
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const spotMarketAccountMap = new Map<number, AccountMeta>();
+		const perpMarketAccountMap = new Map<number, AccountMeta>();
+
+		for (const userAccount of userAccounts) {
+			for (const spotPosition of userAccount.spotPositions) {
+				if (!isSpotPositionAvailable(spotPosition)) {
+					const spotMarket = this.getSpotMarketAccount(
+						spotPosition.marketIndex
+					);
+					spotMarketAccountMap.set(spotPosition.marketIndex, {
+						pubkey: spotMarket.pubkey,
+						isSigner: false,
+						isWritable: false,
+					});
+
+					if (!spotMarket.oracle.equals(PublicKey.default)) {
+						oracleAccountMap.set(spotMarket.oracle.toString(), {
+							pubkey: spotMarket.oracle,
+							isSigner: false,
+							isWritable: false,
+						});
+					}
+				}
+			}
+			for (const position of userAccount.perpPositions) {
+				if (!positionIsAvailable(position)) {
+					const market = this.getPerpMarketAccount(position.marketIndex);
+					perpMarketAccountMap.set(position.marketIndex, {
+						pubkey: market.pubkey,
+						isWritable: false,
+						isSigner: false,
+					});
+					oracleAccountMap.set(market.amm.oracle.toString(), {
+						pubkey: market.amm.oracle,
+						isWritable: false,
+						isSigner: false,
+					});
+				}
+			}
+		}
+
+		return {
+			oracleAccountMap,
+			spotMarketAccountMap,
+			perpMarketAccountMap,
+		};
+	}
+
+	public getOrder(orderId: number): Order | undefined {
+		return this.getUserAccount()?.orders.find(
+			(order) => order.orderId === orderId
 		);
 	}
 
@@ -834,21 +887,14 @@ export class ClearingHouse {
 		let remainingAccounts = [];
 		if (userInitialized) {
 			remainingAccounts = this.getRemainingAccounts({
-				writableSpotMarketIndex: marketIndex,
+				userAccounts: [this.getUserAccount()],
+				useMarketLastSlotCache: true,
+				writableSpotMarketIndexes: [marketIndex],
 			});
 		} else {
-			const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-			if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-				remainingAccounts.push({
-					pubkey: spotMarketAccount.oracle,
-					isSigner: false,
-					isWritable: false,
-				});
-			}
-			remainingAccounts.push({
-				pubkey: spotMarketAccount.pubkey,
-				isSigner: false,
-				isWritable: true,
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [],
+				writableSpotMarketIndexes: [marketIndex],
 			});
 		}
 
@@ -1164,7 +1210,9 @@ export class ClearingHouse {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
@@ -1228,9 +1276,29 @@ export class ClearingHouse {
 			toUserId
 		);
 
-		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
-		});
+		let remainingAccounts;
+		if (this.users.has(fromUserId)) {
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [this.users.get(fromUserId).getUserAccount()],
+				useMarketLastSlotCache: true,
+				writableSpotMarketIndexes: [marketIndex],
+			});
+		} else {
+			const userAccountPublicKey = getUserAccountPublicKeySync(
+				this.program.programId,
+				this.authority,
+				fromUserId
+			);
+
+			const fromUserAccount = (await this.program.account.user.fetch(
+				userAccountPublicKey
+			)) as UserAccount;
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [fromUserAccount],
+				useMarketLastSlotCache: true,
+				writableSpotMarketIndexes: [marketIndex],
+			});
+		}
 
 		return await this.program.instruction.transferDeposit(marketIndex, amount, {
 			accounts: {
@@ -1261,6 +1329,7 @@ export class ClearingHouse {
 		const spotMarket = this.getSpotMarketAccount(marketIndex);
 		return await this.program.instruction.updateSpotMarketCumulativeInterest({
 			accounts: {
+				state: await this.getStatePublicKey(),
 				spotMarket: spotMarket.pubkey,
 			},
 		});
@@ -1285,33 +1354,11 @@ export class ClearingHouse {
 		const settleeUserAccount = (await this.program.account.user.fetch(
 			settleeUserAccountPublicKey
 		)) as UserAccount;
-		const userPositions = settleeUserAccount.perpPositions;
-		const remainingAccounts = [];
-
-		let foundMarket = false;
-		for (const position of userPositions) {
-			if (!positionIsAvailable(position)) {
-				const marketPublicKey = await getMarketPublicKey(
-					this.program.programId,
-					position.marketIndex
-				);
-				remainingAccounts.push({
-					pubkey: marketPublicKey,
-					isWritable: true,
-					isSigner: false,
-				});
-
-				if (marketIndex === position.marketIndex) {
-					foundMarket = true;
-				}
-			}
-		}
 
-		if (!foundMarket) {
-			console.log(
-				'Warning: lp is not in the market specified -- tx will likely fail'
-			);
-		}
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [settleeUserAccount],
+			writablePerpMarketIndexes: [marketIndex],
+		});
 
 		return this.program.instruction.settleLp(marketIndex, {
 			accounts: {
@@ -1341,7 +1388,9 @@ export class ClearingHouse {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writablePerpMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
 		});
 
 		if (sharesToBurn == undefined) {
@@ -1382,7 +1431,9 @@ export class ClearingHouse {
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 		const remainingAccounts = this.getRemainingAccounts({
-			writablePerpMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
 		});
 
 		return this.program.instruction.addLiquidity(amount, marketIndex, {
@@ -1492,6 +1543,8 @@ export class ClearingHouse {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
 			readablePerpMarketIndex: orderParams.marketIndex,
 		});
 
@@ -1599,7 +1652,7 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
+	public async cancelOrder(orderId?: number): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getCancelOrderIx(orderId)),
 			[],
@@ -1608,10 +1661,15 @@ export class ClearingHouse {
 		return txSig;
 	}
 
-	public async getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction> {
+	public async getCancelOrderIx(
+		orderId?: number
+	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccounts({});
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+		});
 
 		return await this.program.instruction.cancelOrder(orderId ?? null, {
 			accounts: {
@@ -1642,7 +1700,10 @@ export class ClearingHouse {
 		const order = this.getOrderByUserId(userOrderId);
 		const oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
 
-		const remainingAccounts = this.getRemainingAccounts({});
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+		});
 
 		return await this.program.instruction.cancelOrderByUserId(userOrderId, {
 			accounts: {
@@ -1658,7 +1719,7 @@ export class ClearingHouse {
 	public async fillOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
-		order?: Order,
+		order?: Pick<Order, 'marketIndex' | 'orderId'>,
 		makerInfo?: MakerInfo,
 		referrerInfo?: ReferrerInfo
 	): Promise<TransactionSignature> {
@@ -1695,72 +1756,19 @@ export class ClearingHouse {
 
 		const marketIndex = order
 			? order.marketIndex
-			: userAccount.orders.find((order) =>
-					order.orderId.eq(userAccount.nextOrderId.sub(ONE))
+			: userAccount.orders.find(
+					(order) => order.orderId === userAccount.nextOrderId - 1
 			  ).marketIndex;
-		const marketAccount = this.getPerpMarketAccount(marketIndex);
-
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		const perpMarketAccountMap = new Map<number, AccountMeta>();
-
-		for (const spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					spotPosition.marketIndex
-				);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
 
-		for (const position of userAccount.perpPositions) {
-			if (
-				!positionIsAvailable(position) &&
-				position.marketIndex !== order.marketIndex
-			) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				perpMarketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
+		const userAccounts = [userAccount];
+		if (makerInfo !== undefined) {
+			userAccounts.push(makerInfo.makerUserAccount);
 		}
-
-		perpMarketAccountMap.set(marketIndex, {
-			pubkey: marketAccount.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isWritable: false,
-			isSigner: false,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts,
+			writablePerpMarketIndexes: [marketIndex],
 		});
 
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...perpMarketAccountMap.values(),
-		];
-
 		if (makerInfo) {
 			remainingAccounts.push({
 				pubkey: makerInfo.maker,
@@ -1821,6 +1829,8 @@ export class ClearingHouse {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
 			readableSpotMarketIndex: orderParams.marketIndex,
 		});
 
@@ -1878,86 +1888,30 @@ export class ClearingHouse {
 
 		const marketIndex = order
 			? order.marketIndex
-			: userAccount.orders.find((order) =>
-					order.orderId.eq(userAccount.nextOrderId.sub(ONE))
+			: userAccount.orders.find(
+					(order) => order.orderId === userAccount.nextOrderId - 1
 			  ).marketIndex;
 
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		const perpMarketAccountMap = new Map<number, AccountMeta>();
-
-		for (const spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarket.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
+		const userAccounts = [userAccount];
+		if (makerInfo !== undefined) {
+			userAccounts.push(makerInfo.makerUserAccount);
+		}
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts,
+			writableSpotMarketIndexes: [marketIndex, QUOTE_SPOT_MARKET_INDEX],
+		});
 
-				if (!spotMarket.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarket.oracle.toString(), {
-						pubkey: spotMarket.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-
-		for (const position of userAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				perpMarketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-		spotMarketAccountMap.set(marketIndex, {
-			pubkey: spotMarketAccount.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-		if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-			oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-				pubkey: spotMarketAccount.oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
-		const quoteMarketAccount = this.getQuoteSpotMarketAccount();
-		spotMarketAccountMap.set(quoteMarketAccount.marketIndex, {
-			pubkey: quoteMarketAccount.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...perpMarketAccountMap.values(),
-		];
-
-		if (makerInfo) {
-			remainingAccounts.push({
-				pubkey: makerInfo.maker,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: makerInfo.makerStats,
-				isWritable: true,
-				isSigner: false,
-			});
+		if (makerInfo) {
+			remainingAccounts.push({
+				pubkey: makerInfo.maker,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: makerInfo.makerStats,
+				isWritable: true,
+				isSigner: false,
+			});
 		}
 
 		if (referrerInfo) {
@@ -2047,12 +2001,12 @@ export class ClearingHouse {
 				isSigner: false,
 			});
 			remainingAccounts.push({
-				pubkey: spotMarketAccount.vault,
+				pubkey: this.getSpotMarketAccount(marketIndex).vault,
 				isWritable: true,
 				isSigner: false,
 			});
 			remainingAccounts.push({
-				pubkey: quoteMarketAccount.vault,
+				pubkey: this.getQuoteSpotMarketAccount().vault,
 				isWritable: true,
 				isSigner: false,
 			});
@@ -2101,176 +2055,25 @@ export class ClearingHouse {
 	): Promise<TransactionInstruction> {
 		const fillerPublicKey = await this.getUserAccountPublicKey();
 
-		const marketIndex = order.marketIndex;
-		const marketAccount = this.getPerpMarketAccount(marketIndex);
-
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		const perpMarketAccountMap = new Map<number, AccountMeta>();
-
-		for (const spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					spotPosition.marketIndex
-				);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-
-		for (const position of userAccount.perpPositions) {
-			if (
-				!positionIsAvailable(position) &&
-				position.marketIndex !== order.marketIndex
-			) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				perpMarketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
+		let remainingAccountsParams;
+		if (isVariant(order.marketType, 'perp')) {
+			remainingAccountsParams = {
+				userAccounts: [userAccount],
+				writablePerpMarketIndexes: [order.marketIndex],
+			};
+		} else {
+			remainingAccountsParams = {
+				userAccounts: [userAccount],
+				writableSpotMarketIndexes: [order.marketIndex, QUOTE_SPOT_MARKET_INDEX],
+			};
 		}
 
-		perpMarketAccountMap.set(marketIndex, {
-			pubkey: marketAccount.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isWritable: false,
-			isSigner: false,
-		});
-
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...perpMarketAccountMap.values(),
-		];
-
-		const orderId = order.orderId;
-		return await this.program.instruction.triggerOrder(orderId, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				filler: fillerPublicKey,
-				user: userAccountPublicKey,
-				authority: this.wallet.publicKey,
-			},
-			remainingAccounts,
-		});
-	}
-
-	public async triggerSpotOrder(
-		userAccountPublicKey: PublicKey,
-		user: UserAccount,
-		order: Order
-	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getTriggerSpotOrderIx(userAccountPublicKey, user, order)
-			),
-			[],
-			this.opts
+		const remainingAccounts = this.getRemainingAccounts(
+			remainingAccountsParams
 		);
-		return txSig;
-	}
-
-	public async getTriggerSpotOrderIx(
-		userAccountPublicKey: PublicKey,
-		userAccount: UserAccount,
-		order: Order
-	): Promise<TransactionInstruction> {
-		const fillerPublicKey = await this.getUserAccountPublicKey();
-
-		const marketIndex = order.marketIndex;
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		const perpMarketAccountMap = new Map<number, AccountMeta>();
-
-		for (const spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					spotPosition.marketIndex
-				);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-
-		for (const position of userAccount.perpPositions) {
-			if (
-				!positionIsAvailable(position) &&
-				position.marketIndex !== order.marketIndex
-			) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				perpMarketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		const quoteSpotMarket = this.getQuoteSpotMarketAccount();
-		spotMarketAccountMap.set(quoteSpotMarket.marketIndex, {
-			pubkey: quoteSpotMarket.pubkey,
-			isWritable: true,
-			isSigner: false,
-		});
-		spotMarketAccountMap.set(marketIndex, {
-			pubkey: spotMarketAccount.pubkey,
-			isWritable: false,
-			isSigner: false,
-		});
-		oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-			pubkey: spotMarketAccount.oracle,
-			isWritable: false,
-			isSigner: false,
-		});
-
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...perpMarketAccountMap.values(),
-		];
 
 		const orderId = order.orderId;
-		return await this.program.instruction.triggerSpotOrder(orderId, {
+		return await this.program.instruction.triggerOrder(orderId, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,
@@ -2306,9 +2109,14 @@ export class ClearingHouse {
 		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
+		const userAccounts = [this.getUserAccount()];
+		if (makerInfo !== undefined) {
+			userAccounts.push(makerInfo.makerUserAccount);
+		}
 		const remainingAccounts = this.getRemainingAccounts({
-			writablePerpMarketIndex: orderParams.marketIndex,
-			writableSpotMarketIndex: QUOTE_SPOT_MARKET_INDEX,
+			userAccounts,
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [orderParams.marketIndex],
 		});
 
 		let makerOrderId = null;
@@ -2381,10 +2189,10 @@ export class ClearingHouse {
 		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		// todo merge this with getRemainingAccounts
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-			counterPartyUserAccount: takerInfo.takerUserAccount,
-			writablePerpMarketIndex: orderParams.marketIndex,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [orderParams.marketIndex],
 		});
 
 		if (referrerInfo) {
@@ -2400,7 +2208,7 @@ export class ClearingHouse {
 			});
 		}
 
-		const takerOrderId = takerInfo!.order!.orderId;
+		const takerOrderId = takerInfo.order.orderId;
 		return await this.program.instruction.placeAndMake(
 			orderParams,
 			takerOrderId,
@@ -2497,70 +2305,12 @@ export class ClearingHouse {
 		settleeUserAccount: UserAccount,
 		marketIndex: number
 	): Promise<TransactionInstruction> {
-		const perpMarketAccountMap = new Map<number, AccountMeta>();
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-
-		for (const position of settleeUserAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				perpMarketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		for (const spotPosition of settleeUserAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					spotPosition.marketIndex
-				);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-				if (spotMarketAccount.marketIndex !== 0) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-
-		const marketAccount = this.getPerpMarketAccount(marketIndex);
-		perpMarketAccountMap.set(marketIndex, {
-			pubkey: marketAccount.pubkey,
-			isSigner: false,
-			isWritable: true,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isSigner: false,
-			isWritable: false,
-		});
-
-		spotMarketAccountMap.set(QUOTE_SPOT_MARKET_INDEX, {
-			pubkey: this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX).pubkey,
-			isSigner: false,
-			isWritable: true,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [settleeUserAccount],
+			writablePerpMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...perpMarketAccountMap.values(),
-		];
-
 		return await this.program.instruction.settlePnl(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
@@ -2595,69 +2345,12 @@ export class ClearingHouse {
 		settleeUserAccount: UserAccount,
 		marketIndex: number
 	): Promise<TransactionInstruction> {
-		const marketAccountMap = new Map<number, AccountMeta>();
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		for (const position of settleeUserAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				marketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		for (const userBankBalance of settleeUserAccount.spotPositions) {
-			if (!userBankBalance.balance.eq(ZERO)) {
-				const bankAccount = this.getSpotMarketAccount(
-					userBankBalance.marketIndex
-				);
-				spotMarketAccountMap.set(userBankBalance.marketIndex, {
-					pubkey: bankAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-				if (bankAccount.marketIndex !== 0) {
-					oracleAccountMap.set(bankAccount.oracle.toString(), {
-						pubkey: bankAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-
-		const marketAccount = this.getPerpMarketAccount(marketIndex);
-		marketAccountMap.set(marketIndex, {
-			pubkey: marketAccount.pubkey,
-			isSigner: false,
-			isWritable: true,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isSigner: false,
-			isWritable: false,
-		});
-
-		spotMarketAccountMap.set(QUOTE_SPOT_MARKET_INDEX, {
-			pubkey: this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX).pubkey,
-			isSigner: false,
-			isWritable: true,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [settleeUserAccount],
+			writablePerpMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...marketAccountMap.values(),
-		];
-
 		return await this.program.instruction.settleExpiredPosition(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
@@ -2704,9 +2397,10 @@ export class ClearingHouse {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-			writablePerpMarketIndex: marketIndex,
-			counterPartyUserAccount: userAccount,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
 		});
 
 		return await this.program.instruction.liquidatePerp(
@@ -2726,7 +2420,7 @@ export class ClearingHouse {
 		);
 	}
 
-	public async liquidateBorrow(
+	public async liquidateSpot(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
 		assetMarketIndex: number,
@@ -2735,7 +2429,7 @@ export class ClearingHouse {
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(
-				await this.getLiquidateBorrowIx(
+				await this.getLiquidateSpotIx(
 					userAccountPublicKey,
 					userAccount,
 					assetMarketIndex,
@@ -2749,21 +2443,28 @@ export class ClearingHouse {
 		return txSig;
 	}
 
-	public async getLiquidateBorrowIx(
+	public async getLiquidateSpotIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
 		assetMarketIndex: number,
 		liabilityMarketIndex: number,
 		maxLiabilityTransfer: BN
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-			counterPartyUserAccount: userAccount,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			useMarketLastSlotCache: true,
 			writableSpotMarketIndexes: [liabilityMarketIndex, assetMarketIndex],
 		});
 
-		return await this.program.instruction.liquidateBorrow(
+		return await this.program.instruction.liquidateSpot(
 			assetMarketIndex,
 			liabilityMarketIndex,
 			maxLiabilityTransfer,
@@ -2772,7 +2473,9 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					authority: this.wallet.publicKey,
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
 				},
 				remainingAccounts: remainingAccounts,
 			}
@@ -2810,11 +2513,17 @@ export class ClearingHouse {
 		liabilityMarketIndex: number,
 		maxLiabilityTransfer: BN
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-			counterPartyUserAccount: userAccount,
-			writablePerpMarketIndex: perpMarketIndex,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writablePerpMarketIndexes: [perpMarketIndex],
 			writableSpotMarketIndexes: [liabilityMarketIndex],
 		});
 
@@ -2827,7 +2536,9 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					authority: this.wallet.publicKey,
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
 				},
 				remainingAccounts: remainingAccounts,
 			}
@@ -2865,11 +2576,17 @@ export class ClearingHouse {
 		assetMarketIndex: number,
 		maxPnlTransfer: BN
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-			counterPartyUserAccount: userAccount,
-			writablePerpMarketIndex: perpMarketIndex,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writablePerpMarketIndexes: [perpMarketIndex],
 			writableSpotMarketIndexes: [assetMarketIndex],
 		});
 
@@ -2882,7 +2599,9 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					authority: this.wallet.publicKey,
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
 				},
 				remainingAccounts: remainingAccounts,
 			}
@@ -2913,12 +2632,18 @@ export class ClearingHouse {
 		userAccount: UserAccount,
 		marketIndex: number
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
-			writablePerpMarketIndex: marketIndex,
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writablePerpMarketIndexes: [marketIndex],
 			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
-			counterPartyUserAccount: userAccount,
 		});
 
 		const spotMarket = this.getSpotMarketAccount(marketIndex);
@@ -2931,7 +2656,9 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					authority: this.wallet.publicKey,
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
 					spotMarketVault: spotMarket.vault,
 					insuranceFundVault: spotMarket.insuranceFundVault,
 					clearingHouseSigner: this.getSignerPublicKey(),
@@ -2942,14 +2669,14 @@ export class ClearingHouse {
 		);
 	}
 
-	public async resolveBorrowBankruptcy(
+	public async resolveSpotBankruptcy(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
 		marketIndex: number
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(
-				await this.getResolveBorrowBankruptcyIx(
+				await this.getResolveSpotBankruptcyIx(
 					userAccountPublicKey,
 					userAccount,
 					marketIndex
@@ -2961,25 +2688,33 @@ export class ClearingHouse {
 		return txSig;
 	}
 
-	public async getResolveBorrowBankruptcyIx(
+	public async getResolveSpotBankruptcyIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
 		marketIndex: number
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
 			writableSpotMarketIndexes: [marketIndex],
-			counterPartyUserAccount: userAccount,
 		});
 
 		const spotMarket = this.getSpotMarketAccount(marketIndex);
 
-		return await this.program.instruction.resolveBorrowBankruptcy(marketIndex, {
+		return await this.program.instruction.resolveSpotBankruptcy(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				authority: this.wallet.publicKey,
 				user: userAccountPublicKey,
+				userStats: userStatsPublicKey,
+				liquidatorStats: liquidatorStatsPublicKey,
 				liquidator: liquidatorPublicKey,
 				spotMarketVault: spotMarket.vault,
 				insuranceFundVault: spotMarket.insuranceFundVault,
@@ -2990,153 +2725,6 @@ export class ClearingHouse {
 		});
 	}
 
-	getRemainingAccountsWithCounterparty(params: {
-		counterPartyUserAccount: UserAccount;
-		writablePerpMarketIndex?: number;
-		writableSpotMarketIndexes?: number[];
-	}): AccountMeta[] {
-		const counterPartyUserAccount = params.counterPartyUserAccount;
-
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const spotMarketAccountMap = new Map<number, AccountMeta>();
-		const marketAccountMap = new Map<number, AccountMeta>();
-		for (const spotPosition of counterPartyUserAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarket.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-
-				if (!spotMarket.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarket.oracle.toString(), {
-						pubkey: spotMarket.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-		for (const position of counterPartyUserAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				marketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		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.getPerpMarketAccount(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 spotPosition of userAccount.spotPositions) {
-			if (!isSpotPositionAvailable(spotPosition)) {
-				const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
-				spotMarketAccountMap.set(spotPosition.marketIndex, {
-					pubkey: spotMarket.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-
-				if (!spotMarket.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarket.oracle.toString(), {
-						pubkey: spotMarket.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-		for (const position of userAccount.perpPositions) {
-			if (!positionIsAvailable(position)) {
-				const market = this.getPerpMarketAccount(position.marketIndex);
-				marketAccountMap.set(position.marketIndex, {
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		if (params.writablePerpMarketIndex !== undefined) {
-			const market = this.getPerpMarketAccount(params.writablePerpMarketIndex);
-			marketAccountMap.set(market.marketIndex, {
-				pubkey: market.pubkey,
-				isSigner: false,
-				isWritable: true,
-			});
-			oracleAccountMap.set(market.amm.oracle.toString(), {
-				pubkey: market.amm.oracle,
-				isSigner: false,
-				isWritable: false,
-			});
-		}
-
-		if (params.writableSpotMarketIndexes !== undefined) {
-			for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
-				const spotMarketAccount = this.getSpotMarketAccount(
-					writableSpotMarketIndex
-				);
-				spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
-					pubkey: spotMarketAccount.pubkey,
-					isSigner: false,
-					isWritable: true,
-				});
-				if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
-					oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-						pubkey: spotMarketAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
-
-		return [
-			...oracleAccountMap.values(),
-			...spotMarketAccountMap.values(),
-			...marketAccountMap.values(),
-		];
-	}
-
 	public async updateFundingRate(
 		oracle: PublicKey,
 		marketIndex: number
@@ -3163,10 +2751,10 @@ export class ClearingHouse {
 	}
 
 	public async settleFundingPayment(
-		userAccount: PublicKey
+		userAccountPublicKey: PublicKey
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getSettleFundingPaymentIx(userAccount)),
+			wrapInTx(await this.getSettleFundingPaymentIx(userAccountPublicKey)),
 			[],
 			this.opts
 		);
@@ -3174,33 +2762,28 @@ export class ClearingHouse {
 	}
 
 	public async getSettleFundingPaymentIx(
-		userAccount: PublicKey
+		userAccountPublicKey: PublicKey
 	): Promise<TransactionInstruction> {
-		const user = (await this.program.account.user.fetch(
-			userAccount
+		const userAccount = (await this.program.account.user.fetch(
+			userAccountPublicKey
 		)) as UserAccount;
 
-		const userPositions = user.perpPositions;
-
-		const remainingAccounts = [];
-		for (const position of userPositions) {
+		const writablePerpMarketIndexes = [];
+		for (const position of userAccount.perpPositions) {
 			if (!positionIsAvailable(position)) {
-				const marketPublicKey = await getMarketPublicKey(
-					this.program.programId,
-					position.marketIndex
-				);
-				remainingAccounts.push({
-					pubkey: marketPublicKey,
-					isWritable: false,
-					isSigner: false,
-				});
+				writablePerpMarketIndexes.push(position.marketIndex);
 			}
 		}
 
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [userAccount],
+			writablePerpMarketIndexes,
+		});
+
 		return await this.program.instruction.settleFundingPayment({
 			accounts: {
 				state: await this.getStatePublicKey(),
-				user: userAccount,
+				user: userAccountPublicKey,
 			},
 			remainingAccounts,
 		});
@@ -3274,7 +2857,9 @@ export class ClearingHouse {
 		);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
 		return await this.program.rpc.addInsuranceFundStake(marketIndex, amount, {
@@ -3284,7 +2869,9 @@ export class ClearingHouse {
 				insuranceFundStake: ifStakeAccountPublicKey,
 				userStats: this.getUserStatsAccountPublicKey(),
 				authority: this.wallet.publicKey,
+				spotMarketVault: spotMarket.vault,
 				insuranceFundVault: spotMarket.insuranceFundVault,
+				clearingHouseSigner: this.getSignerPublicKey(),
 				userTokenAccount: collateralAccountPublicKey,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
@@ -3304,7 +2891,9 @@ export class ClearingHouse {
 		);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
 		return await this.program.rpc.requestRemoveInsuranceFundStake(
@@ -3318,8 +2907,6 @@ export class ClearingHouse {
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.wallet.publicKey,
 					insuranceFundVault: spotMarketAccount.insuranceFundVault,
-					// userTokenAccount: collateralAccountPublicKey,
-					// tokenProgram: TOKEN_PROGRAM_ID,
 				},
 				remainingAccounts,
 			}
@@ -3337,7 +2924,9 @@ export class ClearingHouse {
 		);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
 		return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(
@@ -3350,8 +2939,6 @@ export class ClearingHouse {
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.wallet.publicKey,
 					insuranceFundVault: spotMarketAccount.insuranceFundVault,
-					// userTokenAccount: collateralAccountPublicKey,
-					// tokenProgram: TOKEN_PROGRAM_ID,
 				},
 				remainingAccounts,
 			}
@@ -3370,7 +2957,9 @@ export class ClearingHouse {
 		);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
 		return await this.program.rpc.removeInsuranceFundStake(marketIndex, {
@@ -3395,7 +2984,9 @@ export class ClearingHouse {
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableSpotMarketIndex: marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
 		return await this.program.rpc.settleRevenueToInsuranceFund(marketIndex, {
@@ -3430,8 +3021,10 @@ export class ClearingHouse {
 		perpMarketIndex: number
 	): Promise<TransactionInstruction> {
 		const remainingAccounts = this.getRemainingAccounts({
-			writablePerpMarketIndex: perpMarketIndex,
-			writableSpotMarketIndex: spotMarketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [perpMarketIndex],
+			writableSpotMarketIndexes: [spotMarketIndex],
 		});
 
 		const spotMarket = this.getSpotMarketAccount(spotMarketIndex);