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

package/src/clearingHouse.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, BN, Idl, Program } from '@project-serum/anchor';
-import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import {
 	StateAccount,
 	IWallet,
@@ -11,6 +11,11 @@ import {
 	BankAccount,
 	UserBankBalance,
 	MakerInfo,
+	TakerInfo,
+	OptionalOrderParams,
+	DefaultOrderParams,
+	OrderType,
+	ReferrerInfo,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -23,9 +28,14 @@ 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 {
@@ -33,6 +43,7 @@ import {
 	getMarketPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
+	getUserStatsAccountPublicKey,
 } from './addresses/pda';
 import {
 	ClearingHouseAccountSubscriber,
@@ -41,7 +52,11 @@ import {
 } from './accounts/types';
 import { TxSender } from './tx/types';
 import { wrapInTx } from './tx/utils';
-import { QUOTE_ASSET_BANK_INDEX, ZERO } from './constants/numericConstants';
+import {
+	ONE,
+	QUOTE_ASSET_BANK_INDEX,
+	ZERO,
+} from './constants/numericConstants';
 import { findDirectionToClose, positionIsAvailable } from './math/position';
 import { getTokenAmount } from './math/bankBalance';
 import { DEFAULT_USER_NAME, encodeName } from './userName';
@@ -52,8 +67,9 @@ 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 { WRAPPED_SOL_MINT } from './constants/banks';
+import { ClearingHouseUserStats } from './clearingHouseUserStats';
 
 /**
  * # ClearingHouse
@@ -66,6 +82,7 @@ export class ClearingHouse {
 	provider: AnchorProvider;
 	opts?: ConfirmOptions;
 	users = new Map<number, ClearingHouseUser>();
+	userStats?: ClearingHouseUserStats;
 	activeUserId: number;
 	userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
 	accountSubscriber: ClearingHouseAccountSubscriber;
@@ -109,6 +126,16 @@ 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.wallet.publicKey
+				),
+				accountSubscription: this.userAccountSubscriptionConfig,
+			});
+		}
 
 		let marketIndexes = config.marketIndexes;
 		let bankIndexes = config.bankIndexes;
@@ -180,6 +207,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 +224,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;
 	}
@@ -294,6 +329,7 @@ export class ClearingHouse {
 		}
 
 		this.activeUserId = activeUserId;
+		this.userStatsAccountPublicKey = undefined;
 	}
 
 	public async switchActiveUser(userId: number): Promise<void> {
@@ -312,19 +348,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 +375,51 @@ 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 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 getUser(userId?: number): ClearingHouseUser {
 		userId = userId ?? this.activeUserId;
 		if (!this.users.has(userId)) {
@@ -360,6 +432,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.wallet.publicKey
+		);
+		return this.userStatsAccountPublicKey;
+	}
+
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		return this.getUser().userAccountPublicKey;
 	}
@@ -396,6 +485,7 @@ export class ClearingHouse {
 	getRemainingAccounts(params: {
 		writableMarketIndex?: BN;
 		writableBankIndex?: BN;
+		readableMarketIndex?: BN;
 	}): AccountMeta[] {
 		const userAccountAndSlot = this.getUserAccountAndSlot();
 		if (!userAccountAndSlot) {
@@ -436,8 +526,7 @@ export class ClearingHouse {
 				marketAccountMap.set(marketIndexNum, {
 					pubkey: marketAccount.pubkey,
 					isSigner: false,
-					// isWritable: false, // TODO
-					isWritable: true,
+					isWritable: false,
 				});
 				oracleAccountMap.set(marketAccount.pubkey.toString(), {
 					pubkey: marketAccount.amm.oracle,
@@ -447,6 +536,22 @@ export class ClearingHouse {
 			}
 		}
 
+		if (params.readableMarketIndex) {
+			const marketAccount = this.getMarketAccount(
+				params.readableMarketIndex.toNumber()
+			);
+			marketAccountMap.set(params.readableMarketIndex.toNumber(), {
+				pubkey: marketAccount.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
+			oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+				pubkey: marketAccount.amm.oracle,
+				isSigner: false,
+				isWritable: false,
+			});
+		}
+
 		if (params.writableMarketIndex) {
 			const marketAccount = this.getMarketAccount(
 				params.writableMarketIndex.toNumber()
@@ -524,6 +629,31 @@ export class ClearingHouse {
 		userId?: number,
 		reduceOnly = false
 	): Promise<TransactionSignature> {
+		const tx = new Transaction();
+		const additionalSigners: Array<Signer> = [];
+
+		const bank = this.getBankAccount(bankIndex);
+
+		const isSolBank = bank.mint.equals(WRAPPED_SOL_MINT);
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolBank && collateralAccountPublicKey.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount);
+
+			collateralAccountPublicKey = pubkey;
+
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
+
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
 			bankIndex,
@@ -533,9 +663,26 @@ export class ClearingHouse {
 			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;
 	}
 
@@ -561,13 +708,19 @@ export class ClearingHouse {
 				writableBankIndex: bankIndex,
 			});
 		} else {
-			remainingAccounts = [
-				{
-					pubkey: this.getBankAccount(bankIndex).pubkey,
+			const bankAccount = this.getBankAccount(bankIndex);
+			if (!bankAccount.oracle.equals(PublicKey.default)) {
+				remainingAccounts.push({
+					pubkey: bankAccount.oracle,
 					isSigner: false,
-					isWritable: true,
-				},
-			];
+					isWritable: false,
+				});
+			}
+			remainingAccounts.push({
+				pubkey: bankAccount.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
 		}
 
 		const bank = this.getBankAccount(bankIndex);
@@ -582,6 +735,7 @@ export class ClearingHouse {
 					bank: bank.pubkey,
 					bankVault: bank.vault,
 					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
 					userTokenAccount: userTokenAccount,
 					authority: this.wallet.publicKey,
 					tokenProgram: TOKEN_PROGRAM_ID,
@@ -591,12 +745,119 @@ export class ClearingHouse {
 		);
 	}
 
+	private async checkIfAccountExists(account: PublicKey) {
+		try {
+			const accountInfo = await this.connection.getAccountInfo(account);
+			return accountInfo && true;
+		} catch (e) {
+			// Doesn't already exist
+			return false;
+		}
+	}
+
+	private async getSolWithdrawalIxs(
+		bankIndex: BN,
+		amount: BN
+	): Promise<{
+		ixs: anchor.web3.TransactionInstruction[];
+		signers: Signer[];
+		pubkey: PublicKey;
+	}> {
+		const result = {
+			ixs: [],
+			signers: [],
+			pubkey: PublicKey.default,
+		};
+
+		// Create a temporary wrapped SOL account to store the SOL that we're withdrawing
+
+		const authority = this.wallet.publicKey;
+
+		const { ixs, signers, pubkey } = await this.getWrappedSolAccountCreationIxs(
+			amount
+		);
+		result.pubkey = pubkey;
+
+		ixs.forEach((ix) => {
+			result.ixs.push(ix);
+		});
+
+		signers.forEach((ix) => {
+			result.signers.push(ix);
+		});
+
+		const withdrawIx = await this.getWithdrawIx(
+			amount,
+			bankIndex,
+			pubkey,
+			true
+		);
+
+		result.ixs.push(withdrawIx);
+
+		result.ixs.push(
+			Token.createCloseAccountInstruction(
+				TOKEN_PROGRAM_ID,
+				pubkey,
+				authority,
+				authority,
+				[]
+			)
+		);
+
+		return result;
+	}
+
+	private async getWrappedSolAccountCreationIxs(amount: BN): 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 depositAmountLamports = amount.add(rentSpaceLamports);
+
+		const authority = this.wallet.publicKey;
+
+		result.ixs.push(
+			SystemProgram.createAccount({
+				fromPubkey: authority,
+				newAccountPubkey: wrappedSolAccount.publicKey,
+				lamports: depositAmountLamports.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;
+	}
+
 	/**
 	 * Creates the Clearing House User account for a user, and deposits some initial collateral
-	 * @param userId
-	 * @param name
 	 * @param amount
 	 * @param userTokenAccount
+	 * @param bankIndex
+	 * @param userId
+	 * @param name
 	 * @param fromUserId
 	 * @returns
 	 */
@@ -606,10 +867,40 @@ export class ClearingHouse {
 		bankIndex = new BN(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 bank = this.getBankAccount(bankIndex);
+
+		const isSolBank = bank.mint.equals(WRAPPED_SOL_MINT);
+
+		const tx = new Transaction();
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolBank && userTokenAccount.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const {
+				ixs: startIxs,
+				signers,
+				pubkey,
+			} = await this.getWrappedSolAccountCreationIxs(amount);
+
+			userTokenAccount = pubkey;
+
+			startIxs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
 
 		const depositCollateralIx =
 			fromUserId != null
@@ -623,11 +914,29 @@ export class ClearingHouse {
 						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,32 +944,35 @@ export class ClearingHouse {
 	public async initializeUserAccountForDevnet(
 		userId = 0,
 		name = DEFAULT_USER_NAME,
-		mockUSDCFaucet: MockUSDCFaucet,
-		amount: BN
+		bankIndex: BN,
+		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),
+			bankIndex,
 			associateTokenPublicKey,
 			userId,
 			false,
 			false
 		);
 
-		const tx = new Transaction()
-			.add(createAssociatedAccountIx)
-			.add(mintToIx)
-			.add(initializeUserAccountIx)
-			.add(depositCollateralIx);
+		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToIx);
+
+		if (userId === 0) {
+			tx.add(await this.getInitializeUserStatsIx());
+		}
+		tx.add(initializeUserAccountIx).add(depositCollateralIx);
 
 		const txSig = await this.program.provider.sendAndConfirm(tx, []);
 
@@ -673,16 +985,56 @@ export class ClearingHouse {
 		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 bank = this.getBankAccount(bankIndex);
+
+		const isSolBank = bank.mint.equals(WRAPPED_SOL_MINT);
+
+		const authority = this.wallet.publicKey;
+
+		const createWSOLTokenAccount =
+			isSolBank && userTokenAccount.equals(authority);
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount);
+
+			userTokenAccount = pubkey;
+
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		}
+
+		const withdrawCollateral = await this.getWithdrawIx(
+			amount,
+			bank.bankIndex,
+			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;
@@ -713,6 +1065,7 @@ export class ClearingHouse {
 					bankVault: bank.vault,
 					bankVaultAuthority: bank.vaultAuthority,
 					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
 					userTokenAccount: userTokenAccount,
 					authority: this.wallet.publicKey,
 					tokenProgram: TOKEN_PROGRAM_ID,
@@ -764,6 +1117,7 @@ export class ClearingHouse {
 				authority: this.wallet.publicKey,
 				fromUser,
 				toUser,
+				userStats: this.getUserStatsAccountPublicKey(),
 				state: await this.getStatePublicKey(),
 			},
 			remainingAccounts,
@@ -792,212 +1146,245 @@ export class ClearingHouse {
 		});
 	}
 
-	public async openPosition(
-		direction: PositionDirection,
-		amount: BN,
-		marketIndex: BN,
-		limitPrice?: BN
-	): Promise<TransactionSignature> {
-		return await this.placeAndTake(
-			getMarketOrderParams(
-				marketIndex,
-				direction,
-				ZERO,
-				amount,
-				false,
-				limitPrice
-			)
-		);
-	}
-
-	public async placeOrder(
-		orderParams: OrderParams
+	public async settleLP(
+		settleeUserAccountPublicKey: PublicKey,
+		marketIndex: BN
 	): Promise<TransactionSignature> {
-		const { txSig, slot } = await this.txSender.send(
-			wrapInTx(await this.getPlaceOrderIx(orderParams)),
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.settleLPIx(settleeUserAccountPublicKey, marketIndex)),
 			[],
 			this.opts
 		);
-		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
 		return txSig;
 	}
 
-	public async getPlaceOrderIx(
-		orderParams: OrderParams
+	public async settleLPIx(
+		settleeUserAccountPublicKey: PublicKey,
+		marketIndex: BN
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const settleeUserAccount = (await this.program.account.user.fetch(
+			settleeUserAccountPublicKey
+		)) as UserAccount;
+		const userPositions = settleeUserAccount.positions;
+		const remainingAccounts = [];
+
+		let foundMarket = false;
+		for (const position of userPositions) {
+			if (!positionIsAvailable(position)) {
+				const marketPublicKey = await getMarketPublicKey(
+					this.program.programId,
+					position.marketIndex
+				);
+				remainingAccounts.push({
+					pubkey: marketPublicKey,
+					isWritable: true,
+					isSigner: false,
+				});
 
-		const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-			.oracle;
+				if (marketIndex.eq(position.marketIndex)) {
+					foundMarket = true;
+				}
+			}
+		}
 
-		const remainingAccounts = this.getRemainingAccounts({
-			writableMarketIndex: orderParams.marketIndex,
-		});
+		if (!foundMarket) {
+			console.log(
+				'Warning: lp is not in the market specified -- tx will likely fail'
+			);
+		}
 
-		return await this.program.instruction.placeOrder(orderParams, {
+		return this.program.instruction.settleLp(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
-				authority: this.wallet.publicKey,
-				oracle: priceOracle,
+				user: settleeUserAccountPublicKey,
 			},
-			remainingAccounts,
+			remainingAccounts: remainingAccounts,
 		});
 	}
 
-	public async expireOrders(
-		userAccountPublicKey: PublicKey
+	public async removeLiquidity(
+		marketIndex: BN,
+		sharesToBurn?: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getExpireOrdersIx(userAccountPublicKey)),
+			wrapInTx(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getExpireOrdersIx(
-		userAccountPublicKey: PublicKey
+	public async getRemoveLiquidityIx(
+		marketIndex: BN,
+		sharesToBurn?: BN
 	): Promise<TransactionInstruction> {
-		const fillerPublicKey = await this.getUserAccountPublicKey();
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: marketIndex,
+		});
 
-		return await this.program.instruction.expireOrders({
+		if (sharesToBurn == undefined) {
+			const userAccount = this.getUserAccount();
+			const marketPosition = userAccount.positions.filter((position) =>
+				position.marketIndex.eq(marketIndex)
+			)[0];
+			sharesToBurn = marketPosition.lpShares;
+			console.log('burning lp shares:', sharesToBurn.toString());
+		}
+
+		return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
-				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
 			},
+			remainingAccounts: remainingAccounts,
 		});
 	}
 
-	public async updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getUpdateAMMsIx(marketIndexes)),
+	public async addLiquidity(
+		amount: BN,
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getAddLiquidityIx(amount, marketIndex)),
 			[],
 			this.opts
 		);
+		this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
 		return txSig;
 	}
 
-	public async getUpdateAMMsIx(
-		marketIndexes: BN[]
+	public async getAddLiquidityIx(
+		amount: BN,
+		marketIndex: BN
 	): Promise<TransactionInstruction> {
-		for (let i = marketIndexes.length; i < 5; i++) {
-			marketIndexes.push(new BN(100));
-		}
-		const marketAccountInfos = [];
-		const oracleAccountInfos = [];
-		for (const marketIndex of marketIndexes) {
-			if (!marketIndex.eq(new BN(100))) {
-				const market = this.getMarketAccount(marketIndex);
-				marketAccountInfos.push({
-					pubkey: market.pubkey,
-					isWritable: true,
-					isSigner: false,
-				});
-				oracleAccountInfos.push({
-					pubkey: market.amm.oracle,
-					isWritable: false,
-					isSigner: false,
-				});
-			}
-		}
-		const remainingAccounts = oracleAccountInfos.concat(marketAccountInfos);
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: marketIndex,
+		});
 
-		return await this.program.instruction.updateAmms(marketIndexes, {
+		return this.program.instruction.addLiquidity(amount, marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
 			},
-			remainingAccounts,
+			remainingAccounts: remainingAccounts,
 		});
 	}
 
-	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getCancelOrderIx(orderId)),
+	public async openPosition(
+		direction: PositionDirection,
+		amount: BN,
+		marketIndex: BN,
+		limitPrice?: BN
+	): Promise<TransactionSignature> {
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction,
+			baseAssetAmount: amount,
+			price: limitPrice,
+		});
+	}
+
+	public async placeOrder(
+		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);
 		return txSig;
 	}
 
-	public async getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction> {
+	getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams {
+		return Object.assign({}, DefaultOrderParams, optionalOrderParams);
+	}
+
+	public async getPlaceOrderIx(
+		orderParams: OptionalOrderParams
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccounts({});
+		const remainingAccounts = this.getRemainingAccounts({
+			readableMarketIndex: orderParams.marketIndex,
+		});
 
-		return await this.program.instruction.cancelOrder(orderId ?? null, {
+		return await this.program.instruction.placeOrder(orderParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
 				authority: this.wallet.publicKey,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async cancelOrderByUserId(
-		userOrderId: number
-	): Promise<TransactionSignature> {
+	public async updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getCancelOrderByUserIdIx(userOrderId)),
+			wrapInTx(await this.getUpdateAMMsIx(marketIndexes)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getCancelOrderByUserIdIx(
-		userOrderId: number
+	public async getUpdateAMMsIx(
+		marketIndexes: BN[]
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-
-		const order = this.getOrderByUserId(userOrderId);
-		const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-
-		const remainingAccounts = this.getRemainingAccounts({});
+		for (let i = marketIndexes.length; i < 5; i++) {
+			marketIndexes.push(new BN(100));
+		}
+		const marketAccountInfos = [];
+		const oracleAccountInfos = [];
+		for (const marketIndex of marketIndexes) {
+			if (!marketIndex.eq(new BN(100))) {
+				const market = this.getMarketAccount(marketIndex);
+				marketAccountInfos.push({
+					pubkey: market.pubkey,
+					isWritable: true,
+					isSigner: false,
+				});
+				oracleAccountInfos.push({
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+		const remainingAccounts = oracleAccountInfos.concat(marketAccountInfos);
 
-		return await this.program.instruction.cancelOrderByUserId(userOrderId, {
+		return await this.program.instruction.updateAmms(marketIndexes, {
 			accounts: {
 				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				oracle,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async cancelAllOrders(
-		bestEffort?: boolean
-	): Promise<TransactionSignature> {
+	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getCancelAllOrdersIx(bestEffort)),
+			wrapInTx(await this.getCancelOrderIx(orderId)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getCancelAllOrdersIx(
-		bestEffort?: boolean
-	): Promise<TransactionInstruction> {
+	public async getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({});
 
-		for (const order of this.getUserAccount().orders) {
-			const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
-
-		return await this.program.instruction.cancelAllOrders(bestEffort, {
+		return await this.program.instruction.cancelOrder(orderId ?? null, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
@@ -1007,67 +1394,54 @@ export class ClearingHouse {
 		});
 	}
 
-	public async cancelOrdersByMarketAndSide(
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
+	public async cancelOrderByUserId(
+		userOrderId: number
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getCancelOrdersByMarketAndSideIx(
-					bestEffort,
-					marketIndexOnly,
-					directionOnly
-				)
-			),
+			wrapInTx(await this.getCancelOrderByUserIdIx(userOrderId)),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getCancelOrdersByMarketAndSideIx(
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
+	public async getCancelOrderByUserIdIx(
+		userOrderId: number
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccounts({});
+		const order = this.getOrderByUserId(userOrderId);
+		const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
 
-		for (const order of this.getUserAccount().orders) {
-			const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
+		const remainingAccounts = this.getRemainingAccounts({});
 
-		return await this.program.instruction.cancelOrdersByMarketAndSide(
-			bestEffort,
-			marketIndexOnly,
-			directionOnly,
-			{
-				accounts: {
-					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
-					authority: this.wallet.publicKey,
-				},
-				remainingAccounts,
-			}
-		);
+		return await this.program.instruction.cancelOrderByUserId(userOrderId, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				oracle,
+			},
+			remainingAccounts,
+		});
 	}
 
 	public async fillOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
 		order?: Order,
-		makerInfo?: MakerInfo
+		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
@@ -1079,56 +1453,82 @@ export class ClearingHouse {
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
 		order: Order,
-		makerInfo?: MakerInfo
+		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 marketIndex = order
+			? order.marketIndex
+			: userAccount.orders.find((order) =>
+					order.orderId.eq(userAccount.nextOrderId.sub(ONE))
+			  ).marketIndex;
 		const marketAccount = this.getMarketAccount(marketIndex);
-		const oracle = marketAccount.amm.oracle;
 
-		const bankAccountInfos = [
-			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [
-			{
-				pubkey: marketAccount.pubkey,
-				isWritable: true,
-				isSigner: false,
-			},
-		];
-		const oracleAccountInfos = [
-			{
-				pubkey: marketAccount.amm.oracle,
-				isWritable: false,
-				isSigner: false,
-			},
-		];
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
+
+		for (const bankBalance of userAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
 		for (const position of userAccount.positions) {
 			if (
 				!positionIsAvailable(position) &&
 				!position.marketIndex.eq(order.marketIndex)
 			) {
 				const market = this.getMarketAccount(position.marketIndex);
-				marketAccountInfos.push({
+				marketAccountMap.set(position.marketIndex.toNumber(), {
 					pubkey: market.pubkey,
 					isWritable: false,
 					isSigner: false,
 				});
-				oracleAccountInfos.push({
+				oracleAccountMap.set(market.amm.oracle.toString(), {
 					pubkey: market.amm.oracle,
 					isWritable: false,
 					isSigner: false,
 				});
 			}
 		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
-		);
+
+		marketAccountMap.set(marketIndex.toNumber(), {
+			pubkey: marketAccount.pubkey,
+			isWritable: true,
+			isSigner: false,
+		});
+		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+			pubkey: marketAccount.amm.oracle,
+			isWritable: false,
+			isSigner: false,
+		});
+
+		const remainingAccounts = [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
 
 		if (makerInfo) {
 			remainingAccounts.push({
@@ -1136,17 +1536,37 @@ export class ClearingHouse {
 				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;
+
 		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,
-				oracle: oracle,
 			},
 			remainingAccounts,
 		});
@@ -1175,53 +1595,69 @@ export class ClearingHouse {
 		const marketIndex = order.marketIndex;
 		const marketAccount = this.getMarketAccount(marketIndex);
 
-		const bankAccountInfos = [
-			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
-			},
-		];
-		const marketAccountInfos = [
-			{
-				pubkey: marketAccount.pubkey,
-				isWritable: true,
-				isSigner: false,
-			},
-		];
-		const oracleAccountInfos = [
-			{
-				pubkey: marketAccount.amm.oracle,
-				isWritable: false,
-				isSigner: false,
-			},
-		];
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
+
+		for (const bankBalance of userAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
 		for (const position of userAccount.positions) {
 			if (
 				!positionIsAvailable(position) &&
 				!position.marketIndex.eq(order.marketIndex)
 			) {
 				const market = this.getMarketAccount(position.marketIndex);
-				marketAccountInfos.push({
+				marketAccountMap.set(position.marketIndex.toNumber(), {
 					pubkey: market.pubkey,
 					isWritable: false,
 					isSigner: false,
 				});
-				oracleAccountInfos.push({
+				oracleAccountMap.set(market.amm.oracle.toString(), {
 					pubkey: market.amm.oracle,
 					isWritable: false,
 					isSigner: false,
 				});
 			}
 		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
-		);
 
-		const orderId = order.orderId;
-		return await this.program.instruction.triggerOrder(orderId, {
-			accounts: {
-				state: await this.getStatePublicKey(),
+		marketAccountMap.set(marketIndex.toNumber(), {
+			pubkey: marketAccount.pubkey,
+			isWritable: true,
+			isSigner: false,
+		});
+		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+			pubkey: marketAccount.amm.oracle,
+			isWritable: false,
+			isSigner: false,
+		});
+
+		const remainingAccounts = [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
+
+		const orderId = order.orderId;
+		return await this.program.instruction.triggerOrder(orderId, {
+			accounts: {
+				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
@@ -1231,11 +1667,14 @@ 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
 		);
@@ -1244,14 +1683,14 @@ export class ClearingHouse {
 	}
 
 	public async getPlaceAndTakeIx(
-		orderParams: OrderParams,
-		makerInfo?: MakerInfo
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
+		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const priceOracle = this.getMarketAccount(orderParams.marketIndex).amm
-			.oracle;
-
 		const remainingAccounts = this.getRemainingAccounts({
 			writableMarketIndex: orderParams.marketIndex,
 			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
@@ -1265,6 +1704,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(
@@ -1274,8 +1731,72 @@ 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.toNumber(), slot);
+
+		return txSig;
+	}
+
+	public async getPlaceAndMakeIx(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
+		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		// todo merge this with getRemainingAccounts
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: takerInfo.takerUserAccount,
+			writableMarketIndex: 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,
-					oracle: priceOracle,
 				},
 				remainingAccounts,
 			}
@@ -1287,22 +1808,23 @@ export class ClearingHouse {
 	 * @param marketIndex
 	 * @returns
 	 */
-	public async closePosition(marketIndex: BN): Promise<TransactionSignature> {
+	public async closePosition(
+		marketIndex: BN,
+		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(
@@ -1323,7 +1845,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;
@@ -1356,12 +1885,13 @@ export class ClearingHouse {
 		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
+					isWritable: false,
 					isSigner: false,
 				});
 				oracleAccountMap.set(market.amm.oracle.toString(), {
@@ -1424,72 +1954,451 @@ export class ClearingHouse {
 		});
 	}
 
-	public async liquidate(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async liquidatePerp(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN,
+		maxBaseAssetAmount: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getLiquidateIx(liquidateeUserAccountPublicKey)),
+			wrapInTx(
+				await this.getLiquidatePerpIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex,
+					maxBaseAssetAmount
+				)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getLiquidateIx(
-		liquidateeUserAccountPublicKey: PublicKey
+	public async getLiquidatePerpIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN,
+		maxBaseAssetAmount: BN
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const liquidateeUserAccount = (await this.program.account.user.fetch(
-			liquidateeUserAccountPublicKey
-		)) as UserAccount;
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
-		const bankAccountInfos = [
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			writableMarketIndex: marketIndex,
+			counterPartyUserAccount: userAccount,
+		});
+
+		return await this.program.instruction.liquidatePerp(
+			marketIndex,
+			maxBaseAssetAmount,
 			{
-				pubkey: this.getQuoteAssetBankAccount().pubkey,
-				isSigner: false,
-				isWritable: true,
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidateBorrow(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetBankIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowIx(
+					userAccountPublicKey,
+					userAccount,
+					assetBankIndex,
+					liabilityBankIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		assetBankIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: userAccount,
+			writableBankIndexes: [liabilityBankIndex, assetBankIndex],
+		});
+
+		return await this.program.instruction.liquidateBorrow(
+			assetBankIndex,
+			liabilityBankIndex,
+			maxLiabilityTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidateBorrowForPerpPnl(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidateBorrowForPerpPnlIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					liabilityBankIndex,
+					maxLiabilityTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidateBorrowForPerpPnlIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		liabilityBankIndex: BN,
+		maxLiabilityTransfer: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: userAccount,
+			writableMarketIndex: perpMarketIndex,
+			writableBankIndexes: [liabilityBankIndex],
+		});
+
+		return await this.program.instruction.liquidateBorrowForPerpPnl(
+			perpMarketIndex,
+			liabilityBankIndex,
+			maxLiabilityTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async liquidatePerpPnlForDeposit(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		assetBankIndex: BN,
+		maxPnlTransfer: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getLiquidatePerpPnlForDepositIx(
+					userAccountPublicKey,
+					userAccount,
+					perpMarketIndex,
+					assetBankIndex,
+					maxPnlTransfer
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getLiquidatePerpPnlForDepositIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		perpMarketIndex: BN,
+		assetBankIndex: BN,
+		maxPnlTransfer: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: userAccount,
+			writableMarketIndex: perpMarketIndex,
+			writableBankIndexes: [assetBankIndex],
+		});
+
+		return await this.program.instruction.liquidatePerpPnlForDeposit(
+			perpMarketIndex,
+			assetBankIndex,
+			maxPnlTransfer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async resolvePerpBankruptcy(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN
+	): 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: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			writableMarketIndex: marketIndex,
+			counterPartyUserAccount: userAccount,
+		});
+
+		return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+				user: userAccountPublicKey,
+				liquidator: liquidatorPublicKey,
 			},
-		];
-		const marketAccountInfos = [];
-		const oracleAccountInfos = [];
-		for (const position of liquidateeUserAccount.positions) {
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	public async resolveBorrowBankruptcy(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getResolveBorrowBankruptcyIx(
+					userAccountPublicKey,
+					userAccount,
+					bankIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getResolveBorrowBankruptcyIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		bankIndex: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			writableBankIndexes: [bankIndex],
+			counterPartyUserAccount: userAccount,
+		});
+
+		return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+				user: userAccountPublicKey,
+				liquidator: liquidatorPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	getRemainingAccountsWithCounterparty(params: {
+		counterPartyUserAccount: UserAccount;
+		writableMarketIndex?: BN;
+		writableBankIndexes?: BN[];
+	}): AccountMeta[] {
+		const counterPartyUserAccount = params.counterPartyUserAccount;
+
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
+		for (const bankBalance of counterPartyUserAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+		for (const position of counterPartyUserAccount.positions) {
 			if (!positionIsAvailable(position)) {
 				const market = this.getMarketAccount(position.marketIndex);
-				const marketPublicKey = await getMarketPublicKey(
-					this.program.programId,
-					position.marketIndex
-				);
-				marketAccountInfos.push({
-					pubkey: marketPublicKey,
-					isWritable: true,
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: false,
 					isSigner: false,
 				});
-				oracleAccountInfos.push({
+				oracleAccountMap.set(market.amm.oracle.toString(), {
 					pubkey: market.amm.oracle,
 					isWritable: false,
 					isSigner: false,
 				});
 			}
 		}
-		const remainingAccounts = oracleAccountInfos.concat(
-			bankAccountInfos.concat(marketAccountInfos)
-		);
 
-		const state = this.getStateAccount();
-		const quoteAssetBankAccount = this.getQuoteAssetBankAccount();
-		return await this.program.instruction.liquidate({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				authority: this.wallet.publicKey,
-				user: liquidateeUserAccountPublicKey,
-				liquidator: userAccountPublicKey,
-				bankVault: quoteAssetBankAccount.vault,
-				bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
-				insuranceVault: state.insuranceVault,
-				tokenProgram: TOKEN_PROGRAM_ID,
-			},
-			remainingAccounts: remainingAccounts,
-		});
+		const userAccountAndSlot = this.getUserAccountAndSlot();
+		if (!userAccountAndSlot) {
+			throw Error(
+				'No user account found. Most likely user account does not exist or failed to fetch account'
+			);
+		}
+		const { data: userAccount, slot: lastUserPositionsSlot } =
+			userAccountAndSlot;
+
+		for (const [marketIndexNum, slot] of this.marketLastSlotCache.entries()) {
+			// if cache has more recent slot than user positions account slot, add market to remaining accounts
+			// otherwise remove from slot
+			if (slot > lastUserPositionsSlot) {
+				const marketAccount = this.getMarketAccount(marketIndexNum);
+				marketAccountMap.set(marketIndexNum, {
+					pubkey: marketAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+				oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+					pubkey: marketAccount.amm.oracle,
+					isSigner: false,
+					isWritable: false,
+				});
+			} else {
+				this.marketLastSlotCache.delete(marketIndexNum);
+			}
+		}
+		for (const bankBalance of userAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: false,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+		for (const position of userAccount.positions) {
+			if (!positionIsAvailable(position)) {
+				const market = this.getMarketAccount(position.marketIndex);
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: false,
+					isSigner: false,
+				});
+				oracleAccountMap.set(market.amm.oracle.toString(), {
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+
+		if (params.writableMarketIndex) {
+			const market = this.getMarketAccount(params.writableMarketIndex);
+			marketAccountMap.set(market.marketIndex.toNumber(), {
+				pubkey: market.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
+			oracleAccountMap.set(market.amm.oracle.toString(), {
+				pubkey: market.amm.oracle,
+				isSigner: false,
+				isWritable: false,
+			});
+		}
+
+		if (params.writableBankIndexes) {
+			for (const writableBankIndex of params.writableBankIndexes) {
+				const bank = this.getBankAccount(writableBankIndex);
+				bankAccountMap.set(bank.bankIndex.toNumber(), {
+					pubkey: bank.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+				if (!bank.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bank.oracle.toString(), {
+						pubkey: bank.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
+		return [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
 	}
 
 	public async updateFundingRate(