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

package/src/clearingHouse.ts

@@ -1,16 +1,29 @@
 import { AnchorProvider, BN, Idl, Program } from '@project-serum/anchor';
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import bs58 from 'bs58';
+import {
+	ASSOCIATED_TOKEN_PROGRAM_ID,
+	Token,
+	TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
 import {
 	StateAccount,
 	IWallet,
 	PositionDirection,
 	UserAccount,
-	MarketAccount,
+	PerpMarketAccount,
 	OrderParams,
 	Order,
-	BankAccount,
-	UserBankBalance,
+	SpotMarketAccount,
+	SpotPosition,
 	MakerInfo,
+	TakerInfo,
+	OptionalOrderParams,
+	DefaultOrderParams,
+	OrderType,
+	ReferrerInfo,
+	MarketType,
+	SerumV3FulfillmentConfigAccount,
+	isVariant,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -23,16 +36,26 @@ import {
 	Transaction,
 	TransactionInstruction,
 	AccountMeta,
+	Keypair,
+	LAMPORTS_PER_SOL,
+	Signer,
+	SystemProgram,
+	ComputeBudgetProgram,
 } from '@solana/web3.js';
 
-import { MockUSDCFaucet } from './mockUSDCFaucet';
+import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
+	getClearingHouseSignerPublicKey,
 	getClearingHouseStateAccountPublicKey,
+	getInsuranceFundStakeAccountPublicKey,
 	getMarketPublicKey,
+	getSerumFulfillmentConfigPublicKey,
+	getSerumSignerPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
+	getUserStatsAccountPublicKey,
 } from './addresses/pda';
 import {
 	ClearingHouseAccountSubscriber,
@@ -41,9 +64,9 @@ import {
 } from './accounts/types';
 import { TxSender } from './tx/types';
 import { wrapInTx } from './tx/utils';
-import { QUOTE_ASSET_BANK_INDEX, ZERO } from './constants/numericConstants';
+import { QUOTE_SPOT_MARKET_INDEX } from './constants/numericConstants';
 import { findDirectionToClose, positionIsAvailable } from './math/position';
-import { getTokenAmount } from './math/bankBalance';
+import { getTokenAmount } from './math/spotBalance';
 import { DEFAULT_USER_NAME, encodeName } from './userName';
 import { OraclePriceData } from './oracles/types';
 import { ClearingHouseConfig } from './clearingHouseConfig';
@@ -52,8 +75,19 @@ 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';
+import { getMarketsAndOraclesForSubscription } from './config';
+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
@@ -66,6 +100,7 @@ export class ClearingHouse {
 	provider: AnchorProvider;
 	opts?: ConfirmOptions;
 	users = new Map<number, ClearingHouseUser>();
+	userStats?: ClearingHouseUserStats;
 	activeUserId: number;
 	userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
 	accountSubscriber: ClearingHouseAccountSubscriber;
@@ -73,6 +108,7 @@ export class ClearingHouse {
 	_isSubscribed = false;
 	txSender: TxSender;
 	marketLastSlotCache = new Map<number, number>();
+	authority: PublicKey;
 
 	public get isSubscribed() {
 		return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -97,6 +133,7 @@ export class ClearingHouse {
 			this.provider
 		);
 
+		this.authority = config.authority ?? this.wallet.publicKey;
 		const userIds = config.userIds ?? [0];
 		this.activeUserId = config.activeUserId ?? userIds[0];
 		this.userAccountSubscriptionConfig =
@@ -109,18 +146,32 @@ export class ClearingHouse {
 						type: 'websocket',
 				  };
 		this.createUsers(userIds, this.userAccountSubscriptionConfig);
+		if (config.userStats) {
+			this.userStats = new ClearingHouseUserStats({
+				clearingHouse: this,
+				userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+					this.program.programId,
+					this.authority
+				),
+				accountSubscription: this.userAccountSubscriptionConfig,
+			});
+		}
 
-		let marketIndexes = config.marketIndexes;
-		let bankIndexes = config.bankIndexes;
+		let perpMarketIndexes = config.perpMarketIndexes;
+		let spotMarketIndexes = config.spotMarketIndexes;
 		let oracleInfos = config.oracleInfos;
 		if (config.env) {
 			const {
-				marketIndexes: envMarketIndexes,
-				bankIndexes: envBankIndexes,
+				perpMarketIndexes: envPerpMarketIndexes,
+				spotMarketIndexes: envSpotMarketIndexes,
 				oracleInfos: envOralceInfos,
-			} = getMarketsBanksAndOraclesForSubscription(config.env);
-			marketIndexes = marketIndexes ? marketIndexes : envMarketIndexes;
-			bankIndexes = bankIndexes ? bankIndexes : envBankIndexes;
+			} = getMarketsAndOraclesForSubscription(config.env);
+			perpMarketIndexes = perpMarketIndexes
+				? perpMarketIndexes
+				: envPerpMarketIndexes;
+			spotMarketIndexes = spotMarketIndexes
+				? spotMarketIndexes
+				: envSpotMarketIndexes;
 			oracleInfos = oracleInfos ? oracleInfos : envOralceInfos;
 		}
 
@@ -128,15 +179,15 @@ export class ClearingHouse {
 			this.accountSubscriber = new PollingClearingHouseAccountSubscriber(
 				this.program,
 				config.accountSubscription.accountLoader,
-				marketIndexes ?? [],
-				bankIndexes ?? [],
+				perpMarketIndexes ?? [],
+				spotMarketIndexes ?? [],
 				oracleInfos ?? []
 			);
 		} else {
 			this.accountSubscriber = new WebSocketClearingHouseAccountSubscriber(
 				this.program,
-				config.marketIndexes ?? [],
-				config.bankIndexes ?? [],
+				config.perpMarketIndexes ?? [],
+				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? []
 			);
 		}
@@ -165,7 +216,7 @@ export class ClearingHouse {
 	): ClearingHouseUser {
 		const userAccountPublicKey = getUserAccountPublicKeySync(
 			this.program.programId,
-			this.wallet.publicKey,
+			this.authority,
 			userId
 		);
 
@@ -180,6 +231,9 @@ export class ClearingHouse {
 		const subscribePromises = this.subscribeUsers().concat(
 			this.accountSubscriber.subscribe()
 		);
+		if (this.userStats !== undefined) {
+			subscribePromises.concat(this.userStats.subscribe());
+		}
 		this.isSubscribed = (await Promise.all(subscribePromises)).reduce(
 			(success, prevSuccess) => success && prevSuccess
 		);
@@ -194,17 +248,22 @@ export class ClearingHouse {
 	 *	Forces the accountSubscriber to fetch account updates from rpc
 	 */
 	public async fetchAccounts(): Promise<void> {
-		await Promise.all(
-			[...this.users.values()]
-				.map((user) => user.fetchAccounts())
-				.concat(this.accountSubscriber.fetch())
-		);
+		const promises = [...this.users.values()]
+			.map((user) => user.fetchAccounts())
+			.concat(this.accountSubscriber.fetch());
+		if (this.userStats) {
+			promises.concat(this.userStats.fetchAccounts());
+		}
+		await Promise.all(promises);
 	}
 
 	public async unsubscribe(): Promise<void> {
 		const unsubscribePromises = this.unsubscribeUsers().concat(
 			this.accountSubscriber.unsubscribe()
 		);
+		if (this.userStats !== undefined) {
+			unsubscribePromises.concat(this.userStats.unsubscribe());
+		}
 		await Promise.all(unsubscribePromises);
 		this.isSubscribed = false;
 	}
@@ -224,29 +283,49 @@ export class ClearingHouse {
 		return this.statePublicKey;
 	}
 
+	signerPublicKey?: PublicKey;
+	public getSignerPublicKey(): PublicKey {
+		if (this.signerPublicKey) {
+			return this.signerPublicKey;
+		}
+		this.signerPublicKey = getClearingHouseSignerPublicKey(
+			this.program.programId
+		);
+		return this.signerPublicKey;
+	}
+
 	public getStateAccount(): StateAccount {
 		return this.accountSubscriber.getStateAccountAndSlot().data;
 	}
 
-	public getMarketAccount(marketIndex: BN | number): MarketAccount | undefined {
-		marketIndex = marketIndex instanceof BN ? marketIndex : new BN(marketIndex);
+	public getPerpMarketAccount(
+		marketIndex: number
+	): PerpMarketAccount | undefined {
 		return this.accountSubscriber.getMarketAccountAndSlot(marketIndex)?.data;
 	}
 
-	public getMarketAccounts(): MarketAccount[] {
+	public getPerpMarketAccounts(): PerpMarketAccount[] {
 		return this.accountSubscriber
 			.getMarketAccountsAndSlots()
 			.map((value) => value.data);
 	}
 
-	public getBankAccount(bankIndex: BN | number): BankAccount | undefined {
-		bankIndex = bankIndex instanceof BN ? bankIndex : new BN(bankIndex);
-		return this.accountSubscriber.getBankAccountAndSlot(bankIndex).data;
+	public getSpotMarketAccount(
+		marketIndex: number
+	): SpotMarketAccount | undefined {
+		return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
+	}
+
+	public getSpotMarketAccounts(): SpotMarketAccount[] {
+		return this.accountSubscriber
+			.getSpotMarketAccountsAndSlots()
+			.map((value) => value.data);
 	}
 
-	public getQuoteAssetBankAccount(): BankAccount {
-		return this.accountSubscriber.getBankAccountAndSlot(QUOTE_ASSET_BANK_INDEX)
-			.data;
+	public getQuoteSpotMarketAccount(): SpotMarketAccount {
+		return this.accountSubscriber.getSpotMarketAccountAndSlot(
+			QUOTE_SPOT_MARKET_INDEX
+		).data;
 	}
 
 	public getOraclePriceDataAndSlot(
@@ -255,6 +334,18 @@ export class ClearingHouse {
 		return this.accountSubscriber.getOraclePriceDataAndSlot(oraclePublicKey);
 	}
 
+	public async getSerumV3FulfillmentConfig(
+		serumMarket: PublicKey
+	): Promise<SerumV3FulfillmentConfigAccount> {
+		const address = await getSerumFulfillmentConfigPublicKey(
+			this.program.programId,
+			serumMarket
+		);
+		return (await this.program.account.serumV3FulfillmentConfig.fetch(
+			address
+		)) as SerumV3FulfillmentConfigAccount;
+	}
+
 	/**
 	 * Update the wallet to use for clearing house transactions and linked user account
 	 * @param newWallet
@@ -283,6 +374,7 @@ export class ClearingHouse {
 		this.wallet = newWallet;
 		this.provider = newProvider;
 		this.program = newProgram;
+		this.authority = newWallet.publicKey;
 
 		if (this.isSubscribed) {
 			await Promise.all(this.unsubscribeUsers());
@@ -294,6 +386,7 @@ export class ClearingHouse {
 		}
 
 		this.activeUserId = activeUserId;
+		this.userStatsAccountPublicKey = undefined;
 	}
 
 	public async switchActiveUser(userId: number): Promise<void> {
@@ -312,19 +405,26 @@ export class ClearingHouse {
 
 	public async initializeUserAccount(
 		userId = 0,
-		name = DEFAULT_USER_NAME
+		name = DEFAULT_USER_NAME,
+		referrerInfo?: ReferrerInfo
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [userAccountPublicKey, initializeUserAccountIx] =
-			await this.getInitializeUserInstructions(userId, name);
+			await this.getInitializeUserInstructions(userId, name, referrerInfo);
 
-		const tx = new Transaction().add(initializeUserAccountIx);
+		const tx = new Transaction();
+		if (userId === 0) {
+			// not the safest assumption, can explicitly check if user stats account exists if it causes problems
+			tx.add(await this.getInitializeUserStatsIx());
+		}
+		tx.add(initializeUserAccountIx);
 		const { txSig } = await this.txSender.send(tx, [], this.opts);
 		return [txSig, userAccountPublicKey];
 	}
 
 	async getInitializeUserInstructions(
 		userId = 0,
-		name = DEFAULT_USER_NAME
+		name = DEFAULT_USER_NAME,
+		referrerInfo?: ReferrerInfo
 	): Promise<[PublicKey, TransactionInstruction]> {
 		const userAccountPublicKey = await getUserAccountPublicKey(
 			this.program.programId,
@@ -332,22 +432,147 @@ export class ClearingHouse {
 			userId
 		);
 
+		const remainingAccounts = new Array<AccountMeta>();
+		if (referrerInfo !== undefined) {
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrerStats,
+				isWritable: true,
+				isSigner: false,
+			});
+		}
+
+		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, {
 				accounts: {
 					user: userAccountPublicKey,
+					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(),
 				},
+				remainingAccounts,
 			});
 
 		return [userAccountPublicKey, initializeUserAccountIx];
 	}
 
+	async getInitializeUserStatsIx(): Promise<TransactionInstruction> {
+		return await this.program.instruction.initializeUserStats({
+			accounts: {
+				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 updateUserName(
+		name: string,
+		userId = 0
+	): Promise<TransactionSignature> {
+		const nameBuffer = encodeName(name);
+		return await this.program.rpc.updateUserName(userId, nameBuffer, {
+			accounts: {
+				user: await this.getUserAccountPublicKey(),
+				authority: this.wallet.publicKey,
+			},
+		});
+	}
+
+	public async updateUserCustomMarginRatio(
+		marginRatio: number,
+		userId = 0
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateUserCustomMarginRatio(
+			userId,
+			marginRatio,
+			{
+				accounts: {
+					user: await this.getUserAccountPublicKey(),
+					authority: this.wallet.publicKey,
+				},
+			}
+		);
+	}
+
+	public async updateUserDelegate(
+		delegate: PublicKey,
+		userId = 0
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateUserDelegate(userId, delegate, {
+			accounts: {
+				user: await this.getUserAccountPublicKey(),
+				authority: this.wallet.publicKey,
+			},
+		});
+	}
+
+	public async getUserAccountsForDelegate(
+		delegate: PublicKey
+	): Promise<UserAccount[]> {
+		const programAccounts = await this.program.account.user.all([
+			{
+				memcmp: {
+					offset: 40,
+					/** data to match, as base-58 encoded string and limited to less than 129 bytes */
+					bytes: bs58.encode(delegate.toBuffer()),
+				},
+			},
+		]);
+
+		return programAccounts.map(
+			(programAccount) => programAccount.account as UserAccount
+		);
+	}
+
+	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)) {
@@ -360,6 +585,23 @@ export class ClearingHouse {
 		return [...this.users.values()];
 	}
 
+	public getUserStats(): ClearingHouseUserStats {
+		return this.userStats;
+	}
+
+	userStatsAccountPublicKey: PublicKey;
+	public getUserStatsAccountPublicKey(): PublicKey {
+		if (this.userStatsAccountPublicKey) {
+			return this.userStatsAccountPublicKey;
+		}
+
+		this.userStatsAccountPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			this.authority
+		);
+		return this.userStatsAccountPublicKey;
+	}
+
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		return this.getUser().userAccountPublicKey;
 	}
@@ -374,72 +616,76 @@ export class ClearingHouse {
 		return this.getUser(userId).getUserAccountAndSlot();
 	}
 
-	public getUserBankBalance(
-		bankIndex: number | BN
-	): UserBankBalance | undefined {
-		const bankIndexBN = bankIndex instanceof BN ? bankIndex : new BN(bankIndex);
-		return this.getUserAccount().bankBalances.find((bankBalance) =>
-			bankBalance.bankIndex.eq(bankIndexBN)
+	public getSpotPosition(marketIndex: number): SpotPosition | undefined {
+		return this.getUserAccount().spotPositions.find(
+			(spotPosition) => spotPosition.marketIndex === marketIndex
 		);
 	}
 
 	public getQuoteAssetTokenAmount(): BN {
-		const bank = this.getBankAccount(QUOTE_ASSET_BANK_INDEX);
-		const userBankBalance = this.getUserBankBalance(QUOTE_ASSET_BANK_INDEX);
+		const spotMarket = this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX);
+		const spotPosition = this.getSpotPosition(QUOTE_SPOT_MARKET_INDEX);
 		return getTokenAmount(
-			userBankBalance.balance,
-			bank,
-			userBankBalance.balanceType
+			spotPosition.balance,
+			spotMarket,
+			spotPosition.balanceType
 		);
 	}
 
-	getRemainingAccounts(params: {
-		writableMarketIndex?: BN;
-		writableBankIndex?: BN;
-	}): 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;
+	getRemainingAccounts(params: RemainingAccountParams): AccountMeta[] {
+		const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } =
+			this.getRemainingAccountMapsForUsers(params.userAccounts);
 
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const bankAccountMap = new Map<number, AccountMeta>();
-		const marketAccountMap = 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.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);
+		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);
+				}
 			}
 		}
 
-		for (const position of userAccount.positions) {
-			if (!positionIsAvailable(position)) {
-				const marketIndexNum = position.marketIndex.toNumber();
-				const marketAccount = this.getMarketAccount(marketIndexNum);
-				marketAccountMap.set(marketIndexNum, {
+		if (params.readablePerpMarketIndex !== undefined) {
+			const marketAccount = this.getPerpMarketAccount(
+				params.readablePerpMarketIndex
+			);
+			perpMarketAccountMap.set(params.readablePerpMarketIndex, {
+				pubkey: marketAccount.pubkey,
+				isSigner: false,
+				isWritable: false,
+			});
+			oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+				pubkey: marketAccount.amm.oracle,
+				isSigner: false,
+				isWritable: false,
+			});
+		}
+
+		if (params.writablePerpMarketIndexes !== undefined) {
+			for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+				const marketAccount = this.getPerpMarketAccount(
+					writablePerpMarketIndex
+				);
+				perpMarketAccountMap.set(writablePerpMarketIndex, {
 					pubkey: marketAccount.pubkey,
 					isSigner: false,
-					// isWritable: false, // TODO
 					isWritable: true,
 				});
-				oracleAccountMap.set(marketAccount.pubkey.toString(), {
+				oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
 					pubkey: marketAccount.amm.oracle,
 					isSigner: false,
 					isWritable: false,
@@ -447,67 +693,108 @@ export class ClearingHouse {
 			}
 		}
 
-		if (params.writableMarketIndex) {
-			const marketAccount = this.getMarketAccount(
-				params.writableMarketIndex.toNumber()
+		if (params.readableSpotMarketIndex !== undefined) {
+			const spotMarketAccount = this.getSpotMarketAccount(
+				params.readableSpotMarketIndex
 			);
-			marketAccountMap.set(params.writableMarketIndex.toNumber(), {
-				pubkey: marketAccount.pubkey,
-				isSigner: false,
-				isWritable: true,
-			});
-			oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-				pubkey: marketAccount.amm.oracle,
+			spotMarketAccountMap.set(params.readableSpotMarketIndex, {
+				pubkey: spotMarketAccount.pubkey,
 				isSigner: false,
 				isWritable: false,
 			});
-		}
-
-		for (const userBankBalance of userAccount.bankBalances) {
-			if (!userBankBalance.balance.eq(ZERO)) {
-				const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-				bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-					pubkey: bankAccount.pubkey,
+			if (spotMarketAccount.marketIndex !== 0) {
+				oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+					pubkey: spotMarketAccount.oracle,
 					isSigner: false,
 					isWritable: false,
 				});
-				if (!bankAccount.bankIndex.eq(ZERO)) {
-					oracleAccountMap.set(bankAccount.oracle.toString(), {
-						pubkey: bankAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
 			}
 		}
 
-		if (params.writableBankIndex) {
-			const bankAccount = this.getBankAccount(params.writableBankIndex);
-			bankAccountMap.set(params.writableBankIndex.toNumber(), {
-				pubkey: bankAccount.pubkey,
-				isSigner: false,
-				isWritable: true,
-			});
-			if (!bankAccount.bankIndex.eq(ZERO)) {
-				oracleAccountMap.set(bankAccount.oracle.toString(), {
-					pubkey: bankAccount.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,
+					});
+				}
 			}
 		}
 
 		return [
 			...oracleAccountMap.values(),
-			...bankAccountMap.values(),
-			...marketAccountMap.values(),
+			...spotMarketAccountMap.values(),
+			...perpMarketAccountMap.values(),
 		];
 	}
 
-	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
 		);
 	}
 
@@ -519,29 +806,71 @@ export class ClearingHouse {
 
 	public async deposit(
 		amount: BN,
-		bankIndex: BN,
+		marketIndex: number,
 		collateralAccountPublicKey: PublicKey,
 		userId?: number,
 		reduceOnly = false
 	): Promise<TransactionSignature> {
+		const tx = new Transaction();
+		const additionalSigners: Array<Signer> = [];
+
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+
+		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
+
+		const authority = this.authority;
+
+		const createWSOLTokenAccount =
+			isSolMarket && collateralAccountPublicKey.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount, true);
+
+			collateralAccountPublicKey = pubkey;
+
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
+
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
-			bankIndex,
+			marketIndex,
 			collateralAccountPublicKey,
 			userId,
 			reduceOnly,
 			true
 		);
 
-		const tx = new Transaction().add(depositCollateralIx);
+		tx.add(depositCollateralIx);
+
+		// Close the wrapped sol account at the end of the transaction
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
+					collateralAccountPublicKey,
+					authority,
+					authority,
+					[]
+				)
+			);
+		}
 
-		const { txSig } = await this.txSender.send(tx);
+		const { txSig } = await this.txSender.send(
+			tx,
+			additionalSigners,
+			this.opts
+		);
 		return txSig;
 	}
 
 	async getDepositInstruction(
 		amount: BN,
-		bankIndex: BN,
+		marketIndex: number,
 		userTokenAccount: PublicKey,
 		userId?: number,
 		reduceOnly = false,
@@ -550,7 +879,7 @@ export class ClearingHouse {
 		const userAccountPublicKey = userId
 			? await getUserAccountPublicKey(
 					this.program.programId,
-					this.wallet.publicKey,
+					this.authority,
 					userId
 			  )
 			: await this.getUserAccountPublicKey();
@@ -558,30 +887,30 @@ export class ClearingHouse {
 		let remainingAccounts = [];
 		if (userInitialized) {
 			remainingAccounts = this.getRemainingAccounts({
-				writableBankIndex: bankIndex,
+				userAccounts: [this.getUserAccount()],
+				useMarketLastSlotCache: true,
+				writableSpotMarketIndexes: [marketIndex],
 			});
 		} else {
-			remainingAccounts = [
-				{
-					pubkey: this.getBankAccount(bankIndex).pubkey,
-					isSigner: false,
-					isWritable: true,
-				},
-			];
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [],
+				writableSpotMarketIndexes: [marketIndex],
+			});
 		}
 
-		const bank = this.getBankAccount(bankIndex);
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
 
 		return await this.program.instruction.deposit(
-			bankIndex,
+			marketIndex,
 			amount,
 			reduceOnly,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					bank: bank.pubkey,
-					bankVault: bank.vault,
+					spotMarket: spotMarketAccount.pubkey,
+					spotMarketVault: spotMarketAccount.vault,
 					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
 					userTokenAccount: userTokenAccount,
 					authority: this.wallet.publicKey,
 					tokenProgram: TOKEN_PROGRAM_ID,
@@ -591,43 +920,172 @@ export class ClearingHouse {
 		);
 	}
 
+	private async checkIfAccountExists(account: PublicKey): Promise<boolean> {
+		try {
+			const accountInfo = await this.connection.getAccountInfo(account);
+			return accountInfo != null;
+		} catch (e) {
+			// Doesn't already exist
+			return false;
+		}
+	}
+
+	private async getWrappedSolAccountCreationIxs(
+		amount: BN,
+		isDeposit?: boolean
+	): Promise<{
+		ixs: anchor.web3.TransactionInstruction[];
+		signers: Signer[];
+		pubkey: PublicKey;
+	}> {
+		const wrappedSolAccount = new Keypair();
+
+		const result = {
+			ixs: [],
+			signers: [],
+			pubkey: wrappedSolAccount.publicKey,
+		};
+
+		const rentSpaceLamports = new BN(LAMPORTS_PER_SOL / 100);
+
+		const lamports = isDeposit
+			? amount.add(rentSpaceLamports)
+			: rentSpaceLamports;
+
+		const authority = this.wallet.publicKey;
+
+		result.ixs.push(
+			SystemProgram.createAccount({
+				fromPubkey: authority,
+				newAccountPubkey: wrappedSolAccount.publicKey,
+				lamports: lamports.toNumber(),
+				space: 165,
+				programId: TOKEN_PROGRAM_ID,
+			})
+		);
+
+		result.ixs.push(
+			Token.createInitAccountInstruction(
+				TOKEN_PROGRAM_ID,
+				WRAPPED_SOL_MINT,
+				wrappedSolAccount.publicKey,
+				authority
+			)
+		);
+
+		result.signers.push(wrappedSolAccount);
+
+		return result;
+	}
+
+	public getAssociatedTokenAccountCreationIx(
+		tokenMintAddress: PublicKey,
+		associatedTokenAddress: PublicKey
+	): anchor.web3.TransactionInstruction {
+		const createAssociatedAccountIx =
+			Token.createAssociatedTokenAccountInstruction(
+				ASSOCIATED_TOKEN_PROGRAM_ID,
+				TOKEN_PROGRAM_ID,
+				tokenMintAddress,
+				associatedTokenAddress,
+				this.wallet.publicKey,
+				this.wallet.publicKey
+			);
+
+		return createAssociatedAccountIx;
+	}
+
 	/**
 	 * Creates the Clearing House User account for a user, and deposits some initial collateral
-	 * @param userId
-	 * @param name
 	 * @param amount
 	 * @param userTokenAccount
+	 * @param marketIndex
+	 * @param userId
+	 * @param name
 	 * @param fromUserId
 	 * @returns
 	 */
 	public async initializeUserAccountAndDepositCollateral(
 		amount: BN,
 		userTokenAccount: PublicKey,
-		bankIndex = new BN(0),
+		marketIndex = 0,
 		userId = 0,
 		name = DEFAULT_USER_NAME,
-		fromUserId?: number
+		fromUserId?: number,
+		referrerInfo?: ReferrerInfo
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [userAccountPublicKey, initializeUserAccountIx] =
-			await this.getInitializeUserInstructions(userId, name);
+			await this.getInitializeUserInstructions(userId, name, referrerInfo);
+
+		const additionalSigners: Array<Signer> = [];
+
+		const spotMarket = this.getSpotMarketAccount(marketIndex);
+
+		const isSolMarket = spotMarket.mint.equals(WRAPPED_SOL_MINT);
+
+		const tx = new Transaction();
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolMarket && userTokenAccount.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const {
+				ixs: startIxs,
+				signers,
+				pubkey,
+			} = await this.getWrappedSolAccountCreationIxs(amount, true);
+
+			userTokenAccount = pubkey;
+
+			startIxs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
 
 		const depositCollateralIx =
 			fromUserId != null
-				? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
+				? await this.getTransferDepositIx(
+						amount,
+						marketIndex,
+						fromUserId,
+						userId
+				  )
 				: await this.getDepositInstruction(
 						amount,
-						bankIndex,
+						marketIndex,
 						userTokenAccount,
 						userId,
 						false,
 						false
 				  );
 
-		const tx = new Transaction()
-			.add(initializeUserAccountIx)
-			.add(depositCollateralIx);
+		if (userId === 0) {
+			tx.add(await this.getInitializeUserStatsIx());
+		}
+		tx.add(initializeUserAccountIx).add(depositCollateralIx);
+
+		// Close the wrapped sol account at the end of the transaction
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
+					userTokenAccount,
+					authority,
+					authority,
+					[]
+				)
+			);
+		}
 
-		const { txSig } = await this.txSender.send(tx, []);
+		const { txSig } = await this.txSender.send(
+			tx,
+			additionalSigners,
+			this.opts
+		);
 
 		return [txSig, userAccountPublicKey];
 	}
@@ -635,54 +1093,109 @@ export class ClearingHouse {
 	public async initializeUserAccountForDevnet(
 		userId = 0,
 		name = DEFAULT_USER_NAME,
-		mockUSDCFaucet: MockUSDCFaucet,
-		amount: BN
+		marketIndex: number,
+		tokenFaucet: TokenFaucet,
+		amount: BN,
+		referrerInfo?: ReferrerInfo
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] =
-			await mockUSDCFaucet.createAssociatedTokenAccountAndMintToInstructions(
+			await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(
 				this.wallet.publicKey,
 				amount
 			);
 
 		const [userAccountPublicKey, initializeUserAccountIx] =
-			await this.getInitializeUserInstructions(userId, name);
+			await this.getInitializeUserInstructions(userId, name, referrerInfo);
 
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
-			new BN(0),
+			marketIndex,
 			associateTokenPublicKey,
 			userId,
 			false,
 			false
 		);
 
-		const tx = new Transaction()
-			.add(createAssociatedAccountIx)
-			.add(mintToIx)
-			.add(initializeUserAccountIx)
-			.add(depositCollateralIx);
+		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToIx);
 
-		const txSig = await this.program.provider.sendAndConfirm(tx, []);
+		if (userId === 0) {
+			tx.add(await this.getInitializeUserStatsIx());
+		}
+		tx.add(initializeUserAccountIx).add(depositCollateralIx);
+
+		const txSig = await this.program.provider.sendAndConfirm(tx, []);
 
 		return [txSig, userAccountPublicKey];
 	}
 
 	public async withdraw(
 		amount: BN,
-		bankIndex: BN,
+		marketIndex: number,
 		userTokenAccount: PublicKey,
 		reduceOnly = false
 	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getWithdrawIx(
-					amount,
-					bankIndex,
+		const tx = new Transaction();
+		const additionalSigners: Array<Signer> = [];
+
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+
+		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolMarket && userTokenAccount.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount, false);
+
+			userTokenAccount = pubkey;
+
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		} else {
+			const accountExists = await this.checkIfAccountExists(userTokenAccount);
+
+			if (!accountExists) {
+				const createAssociatedTokenAccountIx =
+					this.getAssociatedTokenAccountCreationIx(
+						spotMarketAccount.mint,
+						userTokenAccount
+					);
+
+				tx.add(createAssociatedTokenAccountIx);
+			}
+		}
+
+		const withdrawCollateral = await this.getWithdrawIx(
+			amount,
+			spotMarketAccount.marketIndex,
+			userTokenAccount,
+			reduceOnly
+		);
+
+		tx.add(withdrawCollateral);
+
+		// Close the wrapped sol account at the end of the transaction
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
 					userTokenAccount,
-					reduceOnly
+					authority,
+					authority,
+					[]
 				)
-			),
-			[],
+			);
+		}
+
+		const { txSig } = await this.txSender.send(
+			tx,
+			additionalSigners,
 			this.opts
 		);
 		return txSig;
@@ -690,29 +1203,32 @@ export class ClearingHouse {
 
 	public async getWithdrawIx(
 		amount: BN,
-		bankIndex: BN,
+		marketIndex: number,
 		userTokenAccount: PublicKey,
 		reduceOnly = false
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableBankIndex: bankIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
 		});
 
-		const bank = this.getBankAccount(bankIndex);
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
 
 		return await this.program.instruction.withdraw(
-			bankIndex,
+			marketIndex,
 			amount,
 			reduceOnly,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					bank: bank.pubkey,
-					bankVault: bank.vault,
-					bankVaultAuthority: bank.vaultAuthority,
+					spotMarket: spotMarketAccount.pubkey,
+					spotMarketVault: spotMarketAccount.vault,
+					clearingHouseSigner: this.getSignerPublicKey(),
 					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
 					userTokenAccount: userTokenAccount,
 					authority: this.wallet.publicKey,
 					tokenProgram: TOKEN_PROGRAM_ID,
@@ -724,13 +1240,18 @@ export class ClearingHouse {
 
 	public async transferDeposit(
 		amount: BN,
-		bankIndex: BN,
+		marketIndex: number,
 		fromUserId: number,
 		toUserId: number
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(
-				await this.getTransferDepositIx(amount, bankIndex, fromUserId, toUserId)
+				await this.getTransferDepositIx(
+					amount,
+					marketIndex,
+					fromUserId,
+					toUserId
+				)
 			),
 			[],
 			this.opts
@@ -740,7 +1261,7 @@ export class ClearingHouse {
 
 	public async getTransferDepositIx(
 		amount: BN,
-		bankIndex: BN,
+		marketIndex: number,
 		fromUserId: number,
 		toUserId: number
 	): Promise<TransactionInstruction> {
@@ -755,93 +1276,292 @@ export class ClearingHouse {
 			toUserId
 		);
 
-		const remainingAccounts = this.getRemainingAccounts({
-			writableBankIndex: bankIndex,
-		});
+		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(bankIndex, amount, {
+		return await this.program.instruction.transferDeposit(marketIndex, amount, {
 			accounts: {
 				authority: this.wallet.publicKey,
 				fromUser,
 				toUser,
+				userStats: this.getUserStatsAccountPublicKey(),
 				state: await this.getStatePublicKey(),
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async updateBankCumulativeInterest(
-		bankIndex: BN
+	public async updateSpotMarketCumulativeInterest(
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.updateSpotMarketCumulativeInterestIx(marketIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async updateSpotMarketCumulativeInterestIx(
+		marketIndex: number
+	): Promise<TransactionInstruction> {
+		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		return await this.program.instruction.updateSpotMarketCumulativeInterest({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				spotMarket: spotMarket.pubkey,
+			},
+		});
+	}
+
+	public async settleLP(
+		settleeUserAccountPublicKey: PublicKey,
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.settleLPIx(settleeUserAccountPublicKey, marketIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async settleLPIx(
+		settleeUserAccountPublicKey: PublicKey,
+		marketIndex: number
+	): Promise<TransactionInstruction> {
+		const settleeUserAccount = (await this.program.account.user.fetch(
+			settleeUserAccountPublicKey
+		)) as UserAccount;
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [settleeUserAccount],
+			writablePerpMarketIndexes: [marketIndex],
+		});
+
+		return this.program.instruction.settleLp(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: settleeUserAccountPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	public async removeLiquidity(
+		marketIndex: number,
+		sharesToBurn?: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.updateBankCumulativeInterestIx(bankIndex)),
+			wrapInTx(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getRemoveLiquidityIx(
+		marketIndex: number,
+		sharesToBurn?: BN
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
+		});
+
+		if (sharesToBurn == undefined) {
+			const userAccount = this.getUserAccount();
+			const perpPosition = userAccount.perpPositions.filter(
+				(position) => position.marketIndex === marketIndex
+			)[0];
+			sharesToBurn = perpPosition.lpShares;
+			console.log('burning lp shares:', sharesToBurn.toString());
+		}
+
+		return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	public async addLiquidity(
+		amount: BN,
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getAddLiquidityIx(amount, marketIndex)),
 			[],
 			this.opts
 		);
+		this.marketLastSlotCache.set(marketIndex, slot);
 		return txSig;
 	}
 
-	public async updateBankCumulativeInterestIx(
-		bankIndex: BN
+	public async getAddLiquidityIx(
+		amount: BN,
+		marketIndex: number
 	): Promise<TransactionInstruction> {
-		const bank = this.getBankAccount(bankIndex);
-		return await this.program.instruction.updateBankCumulativeInterest({
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
+		});
+
+		return this.program.instruction.addLiquidity(amount, marketIndex, {
 			accounts: {
-				bank: bank.pubkey,
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
 			},
+			remainingAccounts: remainingAccounts,
 		});
 	}
 
 	public async openPosition(
 		direction: PositionDirection,
 		amount: BN,
-		marketIndex: BN,
+		marketIndex: number,
 		limitPrice?: BN
 	): Promise<TransactionSignature> {
-		return await this.placeAndTake(
-			getMarketOrderParams(
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction,
+			baseAssetAmount: amount,
+			price: limitPrice,
+		});
+	}
+
+	public async sendSignedTx(tx: Transaction): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(tx, undefined, this.opts, true);
+
+		return txSig;
+	}
+
+	/**
+	 * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
+	 * @param orderParams
+	 * @param userAccountPublicKey
+	 * @param userAccount
+	 * @returns
+	 */
+	public async sendMarketOrderAndGetSignedFillTx(
+		orderParams: OptionalOrderParams,
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount
+	): Promise<{ txSig: TransactionSignature; signedFillTx: Transaction }> {
+		const marketIndex = orderParams.marketIndex;
+		const orderId = userAccount.nextOrderId;
+
+		const marketOrderTx = wrapInTx(await this.getPlaceOrderIx(orderParams));
+		const fillTx = wrapInTx(
+			await this.getFillOrderIx(userAccountPublicKey, userAccount, {
+				orderId,
 				marketIndex,
-				direction,
-				ZERO,
-				amount,
-				false,
-				limitPrice
-			)
+			})
+		);
+
+		// Apply the latest blockhash to the txs so that we can sign before sending them
+		const currentBlockHash = (
+			await this.connection.getLatestBlockhash('finalized')
+		).blockhash;
+		marketOrderTx.recentBlockhash = currentBlockHash;
+		fillTx.recentBlockhash = currentBlockHash;
+
+		marketOrderTx.feePayer = userAccount.authority;
+		fillTx.feePayer = userAccount.authority;
+
+		const [signedMarketOrderTx, signedFillTx] =
+			await this.provider.wallet.signAllTransactions([marketOrderTx, fillTx]);
+
+		const { txSig, slot } = await this.txSender.send(
+			signedMarketOrderTx,
+			[],
+			this.opts,
+			true
 		);
+
+		this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+
+		return { txSig, signedFillTx };
 	}
 
 	public async placeOrder(
-		orderParams: OrderParams
+		orderParams: OptionalOrderParams
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
 			wrapInTx(await this.getPlaceOrderIx(orderParams)),
 			[],
 			this.opts
 		);
-		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+		this.marketLastSlotCache.set(orderParams.marketIndex, slot);
 		return txSig;
 	}
 
+	getOrderParams(
+		optionalOrderParams: OptionalOrderParams,
+		marketType: MarketType
+	): OrderParams {
+		return Object.assign({}, DefaultOrderParams, optionalOrderParams, {
+			marketType,
+		});
+	}
+
 	public async getPlaceOrderIx(
-		orderParams: OrderParams
+		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams, MarketType.PERP);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			writableMarketIndex: orderParams.marketIndex,
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			readablePerpMarketIndex: orderParams.marketIndex,
 		});
 
 		return await this.program.instruction.placeOrder(orderParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
 				authority: this.wallet.publicKey,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature> {
+	public async updateAMMs(
+		marketIndexes: number[]
+	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getUpdateAMMsIx(marketIndexes)),
 			[],
@@ -851,16 +1571,16 @@ export class ClearingHouse {
 	}
 
 	public async getUpdateAMMsIx(
-		marketIndexes: BN[]
+		marketIndexes: number[]
 	): Promise<TransactionInstruction> {
 		for (let i = marketIndexes.length; i < 5; i++) {
-			marketIndexes.push(new BN(100));
+			marketIndexes.push(100);
 		}
 		const marketAccountInfos = [];
 		const oracleAccountInfos = [];
 		for (const marketIndex of marketIndexes) {
-			if (!marketIndex.eq(new BN(100))) {
-				const market = this.getMarketAccount(marketIndex);
+			if (marketIndex !== 100) {
+				const market = this.getPerpMarketAccount(marketIndex);
 				marketAccountInfos.push({
 					pubkey: market.pubkey,
 					isWritable: true,
@@ -884,7 +1604,55 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
+	public async settleExpiredMarket(
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getSettleExpiredMarketIx(marketIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getSettleExpiredMarketIx(
+		marketIndex: number
+	): Promise<TransactionInstruction> {
+		const marketAccountInfos = [];
+		const oracleAccountInfos = [];
+		const spotMarketAccountInfos = [];
+		const market = this.getPerpMarketAccount(marketIndex);
+		marketAccountInfos.push({
+			pubkey: market.pubkey,
+			isWritable: true,
+			isSigner: false,
+		});
+		oracleAccountInfos.push({
+			pubkey: market.amm.oracle,
+			isWritable: false,
+			isSigner: false,
+		});
+
+		spotMarketAccountInfos.push({
+			pubkey: this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX).pubkey,
+			isSigner: false,
+			isWritable: true,
+		});
+
+		const remainingAccounts = oracleAccountInfos
+			.concat(spotMarketAccountInfos)
+			.concat(marketAccountInfos);
+
+		return await this.program.instruction.settleExpiredMarket(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async cancelOrder(orderId?: number): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getCancelOrderIx(orderId)),
 			[],
@@ -893,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: {
@@ -925,9 +1698,12 @@ export class ClearingHouse {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const order = this.getOrderByUserId(userOrderId);
-		const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
+		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: {
@@ -943,12 +1719,19 @@ export class ClearingHouse {
 	public async fillOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
-		order?: Order,
-		makerInfo?: MakerInfo
+		order?: Pick<Order, 'marketIndex' | 'orderId'>,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(
-				await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)
+				await this.getFillOrderIx(
+					userAccountPublicKey,
+					user,
+					order,
+					makerInfo,
+					referrerInfo
+				)
 			),
 			[],
 			this.opts
@@ -959,60 +1742,54 @@ export class ClearingHouse {
 	public async getFillOrderIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
-		order: Order,
-		makerInfo?: MakerInfo
+		order: Pick<Order, 'marketIndex' | 'orderId'>,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const fillerPublicKey = await this.getUserAccountPublicKey();
+		const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
 
-		const marketIndex = order.marketIndex;
-		const marketAccount = this.getMarketAccount(marketIndex);
+		const marketIndex = order
+			? order.marketIndex
+			: userAccount.orders.find(
+					(order) => order.orderId === userAccount.nextOrderId - 1
+			  ).marketIndex;
 
-		const bankAccountInfos = [
-			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [
-			{
-				pubkey: marketAccount.pubkey,
+		const userAccounts = [userAccount];
+		if (makerInfo !== undefined) {
+			userAccounts.push(makerInfo.makerUserAccount);
+		}
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts,
+			writablePerpMarketIndexes: [marketIndex],
+		});
+
+		if (makerInfo) {
+			remainingAccounts.push({
+				pubkey: makerInfo.maker,
 				isWritable: true,
 				isSigner: false,
-			},
-		];
-		const oracleAccountInfos = [
-			{
-				pubkey: marketAccount.amm.oracle,
-				isWritable: false,
+			});
+			remainingAccounts.push({
+				pubkey: makerInfo.makerStats,
+				isWritable: true,
 				isSigner: false,
-			},
-		];
-		for (const position of userAccount.positions) {
-			if (
-				!positionIsAvailable(position) &&
-				!position.marketIndex.eq(order.marketIndex)
-			) {
-				const market = this.getMarketAccount(position.marketIndex);
-				marketAccountInfos.push({
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountInfos.push({
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
+			});
 		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
-		);
 
-		if (makerInfo) {
+		if (referrerInfo) {
 			remainingAccounts.push({
-				pubkey: makerInfo.maker,
+				pubkey: referrerInfo.referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrerStats,
 				isWritable: true,
 				isSigner: false,
 			});
@@ -1020,81 +1797,279 @@ export class ClearingHouse {
 
 		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,
+				fillerStats: fillerStatsPublicKey,
 				user: userAccountPublicKey,
+				userStats: userStatsPublicKey,
 				authority: this.wallet.publicKey,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async triggerOrder(
-		userAccountPublicKey: PublicKey,
-		user: UserAccount,
-		order: Order
+	public async placeSpotOrder(
+		orderParams: OptionalOrderParams
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getTriggerOrderIx(userAccountPublicKey, user, order)),
+			wrapInTx(await this.getPlaceSpotOrderIx(orderParams)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getTriggerOrderIx(
-		userAccountPublicKey: PublicKey,
-		userAccount: UserAccount,
-		order: Order
+	public async getPlaceSpotOrderIx(
+		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
-		const fillerPublicKey = await this.getUserAccountPublicKey();
+		orderParams = this.getOrderParams(orderParams, MarketType.SPOT);
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const marketIndex = order.marketIndex;
-		const marketAccount = this.getMarketAccount(marketIndex);
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			readableSpotMarketIndex: orderParams.marketIndex,
+		});
 
-		const bankAccountInfos = [
-			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [
-			{
-				pubkey: marketAccount.pubkey,
-				isWritable: true,
-				isSigner: false,
+		return await this.program.instruction.placeSpotOrder(orderParams, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
 			},
-		];
-		const oracleAccountInfos = [
-			{
-				pubkey: marketAccount.amm.oracle,
+			remainingAccounts,
+		});
+	}
+
+	public async fillSpotOrder(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		order?: Order,
+		fulfillmentConfig?: SerumV3FulfillmentConfigAccount,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getFillSpotOrderIx(
+					userAccountPublicKey,
+					user,
+					order,
+					fulfillmentConfig,
+					makerInfo,
+					referrerInfo
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getFillSpotOrderIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		order?: Order,
+		fulfillmentConfig?: SerumV3FulfillmentConfigAccount,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
+		const fillerPublicKey = await this.getUserAccountPublicKey();
+		const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
+
+		const marketIndex = order
+			? order.marketIndex
+			: userAccount.orders.find(
+					(order) => order.orderId === userAccount.nextOrderId - 1
+			  ).marketIndex;
+
+		const userAccounts = [userAccount];
+		if (makerInfo !== undefined) {
+			userAccounts.push(makerInfo.makerUserAccount);
+		}
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts,
+			writableSpotMarketIndexes: [marketIndex, QUOTE_SPOT_MARKET_INDEX],
+		});
+
+		if (makerInfo) {
+			remainingAccounts.push({
+				pubkey: makerInfo.maker,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: makerInfo.makerStats,
+				isWritable: true,
+				isSigner: false,
+			});
+		}
+
+		if (referrerInfo) {
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrerStats,
+				isWritable: true,
+				isSigner: false,
+			});
+		}
+
+		const orderId = order.orderId;
+		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+
+		if (fulfillmentConfig) {
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.pubkey,
 				isWritable: false,
 				isSigner: false,
-			},
-		];
-		for (const position of userAccount.positions) {
-			if (
-				!positionIsAvailable(position) &&
-				!position.marketIndex.eq(order.marketIndex)
-			) {
-				const market = this.getMarketAccount(position.marketIndex);
-				marketAccountInfos.push({
-					pubkey: market.pubkey,
-					isWritable: false,
-					isSigner: false,
-				});
-				oracleAccountInfos.push({
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumProgramId,
+				isWritable: false,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumMarket,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumRequestQueue,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumEventQueue,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumBids,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumAsks,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumBaseVault,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumQuoteVault,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: fulfillmentConfig.serumOpenOrders,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: getSerumSignerPublicKey(
+					fulfillmentConfig.serumProgramId,
+					fulfillmentConfig.serumMarket,
+					fulfillmentConfig.serumSignerNonce
+				),
+				isWritable: false,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: this.getSignerPublicKey(),
+				isWritable: false,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: TOKEN_PROGRAM_ID,
+				isWritable: false,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: this.getSpotMarketAccount(marketIndex).vault,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: this.getQuoteSpotMarketAccount().vault,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: this.getStateAccount().srmVault,
+				isWritable: false,
+				isSigner: false,
+			});
+		}
+
+		return await this.program.instruction.fillSpotOrder(
+			orderId,
+			fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null,
+			makerOrderId,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					filler: fillerPublicKey,
+					fillerStats: fillerStatsPublicKey,
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
 			}
+		);
+	}
+
+	public async triggerOrder(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		order: Order
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getTriggerOrderIx(userAccountPublicKey, user, order)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getTriggerOrderIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		order: Order
+	): Promise<TransactionInstruction> {
+		const fillerPublicKey = await this.getUserAccountPublicKey();
+
+		let remainingAccountsParams;
+		if (isVariant(order.marketType, 'perp')) {
+			remainingAccountsParams = {
+				userAccounts: [userAccount],
+				writablePerpMarketIndexes: [order.marketIndex],
+			};
+		} else {
+			remainingAccountsParams = {
+				userAccounts: [userAccount],
+				writableSpotMarketIndexes: [order.marketIndex, QUOTE_SPOT_MARKET_INDEX],
+			};
 		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
+
+		const remainingAccounts = this.getRemainingAccounts(
+			remainingAccountsParams
 		);
 
 		const orderId = order.orderId;
@@ -1110,27 +2085,38 @@ export class ClearingHouse {
 	}
 
 	public async placeAndTake(
-		orderParams: OrderParams,
-		makerInfo?: MakerInfo
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
-			wrapInTx(await this.getPlaceAndTakeIx(orderParams, makerInfo)),
+			wrapInTx(
+				await this.getPlaceAndTakeIx(orderParams, makerInfo, referrerInfo)
+			),
 			[],
 			this.opts
 		);
-		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+		this.marketLastSlotCache.set(orderParams.marketIndex, slot);
 		return txSig;
 	}
 
 	public async getPlaceAndTakeIx(
-		orderParams: OrderParams,
-		makerInfo?: MakerInfo
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams, MarketType.PERP);
+		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({
-			writableMarketIndex: orderParams.marketIndex,
-			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
+			userAccounts,
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [orderParams.marketIndex],
 		});
 
 		let makerOrderId = null;
@@ -1141,6 +2127,24 @@ export class ClearingHouse {
 				isSigner: false,
 				isWritable: true,
 			});
+			remainingAccounts.push({
+				pubkey: makerInfo.makerStats,
+				isSigner: false,
+				isWritable: true,
+			});
+		}
+
+		if (referrerInfo) {
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrerStats,
+				isWritable: true,
+				isSigner: false,
+			});
 		}
 
 		return await this.program.instruction.placeAndTake(
@@ -1150,6 +2154,71 @@ export class ClearingHouse {
 				accounts: {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async placeAndMake(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(
+				await this.getPlaceAndMakeIx(orderParams, takerInfo, referrerInfo)
+			),
+			[],
+			this.opts
+		);
+
+		this.marketLastSlotCache.set(orderParams.marketIndex, slot);
+
+		return txSig;
+	}
+
+	public async getPlaceAndMakeIx(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams, MarketType.PERP);
+		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [orderParams.marketIndex],
+		});
+
+		if (referrerInfo) {
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+			remainingAccounts.push({
+				pubkey: referrerInfo.referrerStats,
+				isWritable: true,
+				isSigner: false,
+			});
+		}
+
+		const takerOrderId = takerInfo.order.orderId;
+		return await this.program.instruction.placeAndMake(
+			orderParams,
+			takerOrderId,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					taker: takerInfo.taker,
+					takerStats: takerInfo.takerStats,
 					authority: this.wallet.publicKey,
 				},
 				remainingAccounts,
@@ -1162,22 +2231,23 @@ export class ClearingHouse {
 	 * @param marketIndex
 	 * @returns
 	 */
-	public async closePosition(marketIndex: BN): Promise<TransactionSignature> {
+	public async closePosition(
+		marketIndex: number,
+		limitPrice?: BN
+	): Promise<TransactionSignature> {
 		const userPosition = this.getUser().getUserPosition(marketIndex);
 		if (!userPosition) {
 			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.abs(),
+			reduceOnly: true,
+			price: limitPrice,
+		});
 	}
 
 	public async settlePNLs(
@@ -1185,7 +2255,7 @@ export class ClearingHouse {
 			settleeUserAccountPublicKey: PublicKey;
 			settleeUserAccount: UserAccount;
 		}[],
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
 		const ixs = [];
 		for (const { settleeUserAccountPublicKey, settleeUserAccount } of users) {
@@ -1198,7 +2268,14 @@ export class ClearingHouse {
 			);
 		}
 
-		const tx = new Transaction().add(...ixs);
+		const tx = new Transaction()
+			.add(
+				ComputeBudgetProgram.requestUnits({
+					units: 1_000_000,
+					additionalFee: 0,
+				})
+			)
+			.add(...ixs);
 
 		const { txSig } = await this.txSender.send(tx, [], this.opts);
 		return txSig;
@@ -1207,7 +2284,7 @@ export class ClearingHouse {
 	public async settlePNL(
 		settleeUserAccountPublicKey: PublicKey,
 		settleeUserAccount: UserAccount,
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(
@@ -1226,70 +2303,55 @@ export class ClearingHouse {
 	public async settlePNLIx(
 		settleeUserAccountPublicKey: PublicKey,
 		settleeUserAccount: UserAccount,
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionInstruction> {
-		const marketAccountMap = new Map<number, AccountMeta>();
-		const oracleAccountMap = new Map<string, AccountMeta>();
-		const bankAccountMap = new Map<number, AccountMeta>();
-		for (const position of settleeUserAccount.positions) {
-			if (!positionIsAvailable(position)) {
-				const market = this.getMarketAccount(position.marketIndex);
-				marketAccountMap.set(position.marketIndex.toNumber(), {
-					pubkey: market.pubkey,
-					isWritable: true, // TODO
-					isSigner: false,
-				});
-				oracleAccountMap.set(market.amm.oracle.toString(), {
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-
-		for (const userBankBalance of settleeUserAccount.bankBalances) {
-			if (!userBankBalance.balance.eq(QUOTE_ASSET_BANK_INDEX)) {
-				const bankAccount = this.getBankAccount(userBankBalance.bankIndex);
-				bankAccountMap.set(userBankBalance.bankIndex.toNumber(), {
-					pubkey: bankAccount.pubkey,
-					isSigner: false,
-					isWritable: false,
-				});
-				if (!bankAccount.bankIndex.eq(ZERO)) {
-					oracleAccountMap.set(bankAccount.oracle.toString(), {
-						pubkey: bankAccount.oracle,
-						isSigner: false,
-						isWritable: false,
-					});
-				}
-			}
-		}
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [settleeUserAccount],
+			writablePerpMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
+		});
 
-		const marketAccount = this.getMarketAccount(marketIndex.toNumber());
-		marketAccountMap.set(marketIndex.toNumber(), {
-			pubkey: marketAccount.pubkey,
-			isSigner: false,
-			isWritable: true,
-		});
-		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
-			pubkey: marketAccount.amm.oracle,
-			isSigner: false,
-			isWritable: false,
+		return await this.program.instruction.settlePnl(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+				user: settleeUserAccountPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
 		});
+	}
 
-		bankAccountMap.set(QUOTE_ASSET_BANK_INDEX.toNumber(), {
-			pubkey: this.getBankAccount(QUOTE_ASSET_BANK_INDEX).pubkey,
-			isSigner: false,
-			isWritable: true,
-		});
+	public async settleExpiredPosition(
+		settleeUserAccountPublicKey: PublicKey,
+		settleeUserAccount: UserAccount,
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getSettleExpiredPositionIx(
+					settleeUserAccountPublicKey,
+					settleeUserAccount,
+					marketIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
 
-		const remainingAccounts = [
-			...oracleAccountMap.values(),
-			...bankAccountMap.values(),
-			...marketAccountMap.values(),
-		];
+	public async getSettleExpiredPositionIx(
+		settleeUserAccountPublicKey: PublicKey,
+		settleeUserAccount: UserAccount,
+		marketIndex: number
+	): Promise<TransactionInstruction> {
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [settleeUserAccount],
+			writablePerpMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
+		});
 
-		return await this.program.instruction.settlePnl(marketIndex, {
+		return await this.program.instruction.settleExpiredPosition(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				authority: this.wallet.publicKey,
@@ -1299,68 +2361,364 @@ export class ClearingHouse {
 		});
 	}
 
-	public async liquidate(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async liquidatePerp(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: number,
+		maxBaseAssetAmount: BN
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidatePerpIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex,
+					maxBaseAssetAmount
+				)
+			),
+			[],
+			this.opts
+		);
+		this.marketLastSlotCache.set(marketIndex, slot);
+		return txSig;
+	}
+
+	public async getLiquidatePerpIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: number,
+		maxBaseAssetAmount: BN
+	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
+		});
+
+		return await this.program.instruction.liquidatePerp(
+			marketIndex,
+			maxBaseAssetAmount,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidateSpot(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetMarketIndex: number,
+		liabilityMarketIndex: number,
+		maxLiabilityTransfer: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getLiquidateIx(liquidateeUserAccountPublicKey)),
+			wrapInTx(
+				await this.getLiquidateSpotIx(
+					userAccountPublicKey,
+					userAccount,
+					assetMarketIndex,
+					liabilityMarketIndex,
+					maxLiabilityTransfer
+				)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getLiquidateIx(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async getLiquidateSpotIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetMarketIndex: number,
+		liabilityMarketIndex: number,
+		maxLiabilityTransfer: BN
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const liquidateeUserAccount = (await this.program.account.user.fetch(
-			liquidateeUserAccountPublicKey
-		)) as UserAccount;
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = await this.getUserStatsAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [liabilityMarketIndex, assetMarketIndex],
+		});
 
-		const bankAccountInfos = [
+		return await this.program.instruction.liquidateSpot(
+			assetMarketIndex,
+			liabilityMarketIndex,
+			maxLiabilityTransfer,
 			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [];
-		const oracleAccountInfos = [];
-		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,
-					isSigner: false,
-				});
-				oracleAccountInfos.push({
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
 			}
-		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
 		);
+	}
 
-		const state = this.getStateAccount();
-		const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
-		return await this.program.instruction.liquidate({
+	public async liquidateBorrowForPerpPnl(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: number,
+		liabilityMarketIndex: number,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowForPerpPnlIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					liabilityMarketIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		this.marketLastSlotCache.set(perpMarketIndex, slot);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowForPerpPnlIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: 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.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writablePerpMarketIndexes: [perpMarketIndex],
+			writableSpotMarketIndexes: [liabilityMarketIndex],
+		});
+
+		return await this.program.instruction.liquidateBorrowForPerpPnl(
+			perpMarketIndex,
+			liabilityMarketIndex,
+			maxLiabilityTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidatePerpPnlForDeposit(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: number,
+		assetMarketIndex: number,
+		maxPnlTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidatePerpPnlForDepositIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					assetMarketIndex,
+					maxPnlTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		this.marketLastSlotCache.set(perpMarketIndex, slot);
+		return txSig;
+	}
+
+	public async getLiquidatePerpPnlForDepositIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: number,
+		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.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writablePerpMarketIndexes: [perpMarketIndex],
+			writableSpotMarketIndexes: [assetMarketIndex],
+		});
+
+		return await this.program.instruction.liquidatePerpPnlForDeposit(
+			perpMarketIndex,
+			assetMarketIndex,
+			maxPnlTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async resolvePerpBankruptcy(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getResolvePerpBankruptcyIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getResolvePerpBankruptcyIx(
+		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.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writablePerpMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
+		});
+
+		const spotMarket = this.getSpotMarketAccount(marketIndex);
+
+		return await this.program.instruction.resolvePerpBankruptcy(
+			QUOTE_SPOT_MARKET_INDEX,
+			marketIndex,
+			{
+				accounts: {
+					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(),
+					tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async resolveSpotBankruptcy(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getResolveSpotBankruptcyIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	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.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), userAccount],
+			writableSpotMarketIndexes: [marketIndex],
+		});
+
+		const spotMarket = this.getSpotMarketAccount(marketIndex);
+
+		return await this.program.instruction.resolveSpotBankruptcy(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				authority: this.wallet.publicKey,
-				user: liquidateeUserAccountPublicKey,
-				liquidator: userAccountPublicKey,
-				bankVault: quoteAssetBankAccount.vault,
-				bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
-				insuranceVault: state.insuranceVault,
+				user: userAccountPublicKey,
+				userStats: userStatsPublicKey,
+				liquidatorStats: liquidatorStatsPublicKey,
+				liquidator: liquidatorPublicKey,
+				spotMarketVault: spotMarket.vault,
+				insuranceFundVault: spotMarket.insuranceFundVault,
+				clearingHouseSigner: this.getSignerPublicKey(),
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 			remainingAccounts: remainingAccounts,
@@ -1369,7 +2727,7 @@ export class ClearingHouse {
 
 	public async updateFundingRate(
 		oracle: PublicKey,
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getUpdateFundingRateIx(oracle, marketIndex)),
@@ -1381,7 +2739,7 @@ export class ClearingHouse {
 
 	public async getUpdateFundingRateIx(
 		oracle: PublicKey,
-		marketIndex: BN
+		marketIndex: number
 	): Promise<TransactionInstruction> {
 		return await this.program.instruction.updateFundingRate(marketIndex, {
 			accounts: {
@@ -1393,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
 		);
@@ -1404,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.positions;
-
-		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,
 		});
@@ -1440,10 +2793,256 @@ export class ClearingHouse {
 		this.eventEmitter.emit(eventName, data);
 	}
 
-	public getOracleDataForMarket(marketIndex: BN): OraclePriceData {
-		const oracleKey = this.getMarketAccount(marketIndex).amm.oracle;
+	public getOracleDataForMarket(marketIndex: number): OraclePriceData {
+		const oracleKey = this.getPerpMarketAccount(marketIndex).amm.oracle;
 		const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
 
 		return oracleData;
 	}
+
+	public getOracleDataForSpotMarket(marketIndex: number): OraclePriceData {
+		const oracleKey = this.getSpotMarketAccount(marketIndex).oracle;
+		const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
+
+		return oracleData;
+	}
+
+	public async initializeInsuranceFundStake(
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getInitializeInsuranceFundStakeIx(marketIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getInitializeInsuranceFundStakeIx(
+		marketIndex: number
+	): Promise<TransactionInstruction> {
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			marketIndex
+		);
+
+		return await this.program.instruction.initializeInsuranceFundStake(
+			marketIndex,
+			{
+				accounts: {
+					insuranceFundStake: ifStakeAccountPublicKey,
+					spotMarket: this.getSpotMarketAccount(marketIndex).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(
+		marketIndex: number,
+		amount: BN,
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			marketIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
+		});
+
+		return await this.program.rpc.addInsuranceFundStake(marketIndex, amount, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				spotMarket: spotMarket.pubkey,
+				insuranceFundStake: ifStakeAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				spotMarketVault: spotMarket.vault,
+				insuranceFundVault: spotMarket.insuranceFundVault,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				userTokenAccount: collateralAccountPublicKey,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async requestRemoveInsuranceFundStake(
+		marketIndex: number,
+		amount: BN
+	): Promise<TransactionSignature> {
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			marketIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
+		});
+
+		return await this.program.rpc.requestRemoveInsuranceFundStake(
+			marketIndex,
+			amount,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					spotMarket: spotMarketAccount.pubkey,
+					insuranceFundStake: ifStakeAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+					insuranceFundVault: spotMarketAccount.insuranceFundVault,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async cancelRequestRemoveInsuranceFundStake(
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			marketIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
+		});
+
+		return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(
+			marketIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					spotMarket: spotMarketAccount.pubkey,
+					insuranceFundStake: ifStakeAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+					insuranceFundVault: spotMarketAccount.insuranceFundVault,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async removeInsuranceFundStake(
+		marketIndex: number,
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			marketIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
+		});
+
+		return await this.program.rpc.removeInsuranceFundStake(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				spotMarket: spotMarketAccount.pubkey,
+				insuranceFundStake: ifStakeAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				insuranceFundVault: spotMarketAccount.insuranceFundVault,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				userTokenAccount: collateralAccountPublicKey,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async settleRevenueToInsuranceFund(
+		marketIndex: number
+	): Promise<TransactionSignature> {
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [marketIndex],
+		});
+
+		return await this.program.rpc.settleRevenueToInsuranceFund(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				spotMarket: spotMarketAccount.pubkey,
+				spotMarketVault: spotMarketAccount.vault,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				insuranceFundVault: spotMarketAccount.insuranceFundVault,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async resolvePerpPnlDeficit(
+		spotMarketIndex: number,
+		perpMarketIndex: number
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getResolvePerpPnlDeficitIx(
+		spotMarketIndex: number,
+		perpMarketIndex: number
+	): Promise<TransactionInstruction> {
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [perpMarketIndex],
+			writableSpotMarketIndexes: [spotMarketIndex],
+		});
+
+		const spotMarket = this.getSpotMarketAccount(spotMarketIndex);
+
+		return await this.program.instruction.resolvePerpPnlDeficit(
+			spotMarketIndex,
+			perpMarketIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					spotMarketVault: spotMarket.vault,
+					insuranceFundVault: spotMarket.insuranceFundVault,
+					clearingHouseSigner: this.getSignerPublicKey(),
+					tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
 }