@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/clearingHouse.ts

@@ -1,28 +1,20 @@
 import { AnchorProvider, BN, Idl, Program } from '@project-serum/anchor';
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import {
-	ASSOCIATED_TOKEN_PROGRAM_ID,
-	Token,
-	TOKEN_PROGRAM_ID,
-} from '@solana/spl-token';
-import {
-	MarketsAccount,
 	StateAccount,
-	DepositHistoryAccount,
-	FundingPaymentHistoryAccount,
-	FundingRateHistoryAccount,
 	IWallet,
-	LiquidationHistoryAccount,
 	PositionDirection,
-	TradeHistoryAccount,
 	UserAccount,
-	Market,
-	OrderHistoryAccount,
-	OrderStateAccount,
+	MarketAccount,
 	OrderParams,
 	Order,
-	ExtendedCurveHistoryAccount,
-	UserPositionsAccount,
-	SettlementStateAccount,
+	BankAccount,
+	UserBankBalance,
+	MakerInfo,
+	TakerInfo,
+	OptionalOrderParams,
+	DefaultOrderParams,
+	OrderType,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -31,10 +23,10 @@ import {
 	Connection,
 	PublicKey,
 	TransactionSignature,
-	Keypair,
 	ConfirmOptions,
 	Transaction,
 	TransactionInstruction,
+	AccountMeta,
 } from '@solana/web3.js';
 
 import { MockUSDCFaucet } from './mockUSDCFaucet';
@@ -42,40 +34,33 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
 	getClearingHouseStateAccountPublicKey,
-	getOrderStateAccountPublicKey,
-	getSettlementStatePublicKey,
+	getMarketPublicKey,
 	getUserAccountPublicKey,
-	getUserAccountPublicKeyAndNonce,
-	getUserOrdersAccountPublicKey,
-	getUserOrdersAccountPublicKeyAndNonce,
-} from './addresses';
+	getUserAccountPublicKeySync,
+} from './addresses/pda';
 import {
 	ClearingHouseAccountSubscriber,
 	ClearingHouseAccountEvents,
-	ClearingHouseAccountTypes,
+	DataAndSlot,
 } from './accounts/types';
 import { TxSender } from './tx/types';
 import { wrapInTx } from './tx/utils';
-import {
-	getClearingHouse,
-	getPollingClearingHouseConfig,
-	getWebSocketClearingHouseConfig,
-} from './factory/clearingHouse';
-import { ZERO } from './constants/numericConstants';
-import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { 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';
+import { OraclePriceData } from './oracles/types';
+import { ClearingHouseConfig } from './clearingHouseConfig';
+import { PollingClearingHouseAccountSubscriber } from './accounts/pollingClearingHouseAccountSubscriber';
+import { WebSocketClearingHouseAccountSubscriber } from './accounts/webSocketClearingHouseAccountSubscriber';
+import { RetryTxSender } from './tx/retryTxSender';
 import { ClearingHouseUser } from './clearingHouseUser';
-import {
-	getClearingHouseUser,
-	getPollingClearingHouseUserConfig,
-} from './factory/clearingHouseUser';
-import { bulkPollingUserSubscribe } from './accounts/bulkUserSubscription';
+import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
+import { getMarketsBanksAndOraclesForSubscription } from './config';
 
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
- *
- * The default way to construct a ClearingHouse instance is using the {@link from} method. This will create an instance using the static {@link WebSocketClearingHouseAccountSubscriber}, which will use a websocket for each state account subscription.
- * Alternatively, if you want to implement your own method of subscribing to the state accounts on the blockchain, you can implement a {@link ClearingHouseAccountSubscriber} and use it in the {@link ClearingHouse.constructor}
  */
 export class ClearingHouse {
 	connection: Connection;
@@ -83,10 +68,14 @@ export class ClearingHouse {
 	public program: Program;
 	provider: AnchorProvider;
 	opts?: ConfirmOptions;
+	users = new Map<number, ClearingHouseUser>();
+	activeUserId: number;
+	userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
 	accountSubscriber: ClearingHouseAccountSubscriber;
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
 	_isSubscribed = false;
 	txSender: TxSender;
+	marketLastSlotCache = new Map<number, number>();
 
 	public get isSubscribed() {
 		return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -96,91 +85,137 @@ export class ClearingHouse {
 		this._isSubscribed = val;
 	}
 
-	/**
-	 * @deprecated You should use the getClearingHouse factory method instead
-	 * @param connection
-	 * @param wallet
-	 * @param clearingHouseProgramId
-	 * @param opts
-	 * @returns
-	 */
-	public static from(
-		connection: Connection,
-		wallet: IWallet,
-		clearingHouseProgramId: PublicKey,
-		opts: ConfirmOptions = AnchorProvider.defaultOptions()
-	): ClearingHouse {
-		const config = getWebSocketClearingHouseConfig(
-			connection,
-			wallet,
-			clearingHouseProgramId,
-			opts
+	public constructor(config: ClearingHouseConfig) {
+		this.connection = config.connection;
+		this.wallet = config.wallet;
+		this.opts = config.opts || AnchorProvider.defaultOptions();
+		this.provider = new AnchorProvider(
+			config.connection,
+			config.wallet,
+			this.opts
+		);
+		this.program = new Program(
+			clearingHouseIDL as Idl,
+			config.programID,
+			this.provider
 		);
-		return getClearingHouse(config);
-	}
-
-	public constructor(
-		connection: Connection,
-		wallet: IWallet,
-		program: Program,
-		accountSubscriber: ClearingHouseAccountSubscriber,
-		txSender: TxSender,
-		opts: ConfirmOptions
-	) {
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts;
-		this.program = program;
-		this.accountSubscriber = accountSubscriber;
+
+		const userIds = config.userIds ?? [0];
+		this.activeUserId = config.activeUserId ?? userIds[0];
+		this.userAccountSubscriptionConfig =
+			config.accountSubscription?.type === 'polling'
+				? {
+						type: 'polling',
+						accountLoader: config.accountSubscription.accountLoader,
+				  }
+				: {
+						type: 'websocket',
+				  };
+		this.createUsers(userIds, this.userAccountSubscriptionConfig);
+
+		let marketIndexes = config.marketIndexes;
+		let bankIndexes = config.bankIndexes;
+		let oracleInfos = config.oracleInfos;
+		if (config.env) {
+			const {
+				marketIndexes: envMarketIndexes,
+				bankIndexes: envBankIndexes,
+				oracleInfos: envOralceInfos,
+			} = getMarketsBanksAndOraclesForSubscription(config.env);
+			marketIndexes = marketIndexes ? marketIndexes : envMarketIndexes;
+			bankIndexes = bankIndexes ? bankIndexes : envBankIndexes;
+			oracleInfos = oracleInfos ? oracleInfos : envOralceInfos;
+		}
+
+		if (config.accountSubscription?.type === 'polling') {
+			this.accountSubscriber = new PollingClearingHouseAccountSubscriber(
+				this.program,
+				config.accountSubscription.accountLoader,
+				marketIndexes ?? [],
+				bankIndexes ?? [],
+				oracleInfos ?? []
+			);
+		} else {
+			this.accountSubscriber = new WebSocketClearingHouseAccountSubscriber(
+				this.program,
+				config.marketIndexes ?? [],
+				config.bankIndexes ?? [],
+				config.oracleInfos ?? []
+			);
+		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
-		this.txSender = txSender;
+		this.txSender = new RetryTxSender(
+			this.provider,
+			config.txSenderConfig?.timeout,
+			config.txSenderConfig?.retrySleep,
+			config.txSenderConfig?.additionalConnections
+		);
 	}
 
-	/**
-	 *
-	 * @param optionalSubscriptions - Optional extra accounts to subcribe to. Always subscribes to base clearing house state and market account state by default. You should only subscribe to optional extra accounts if required, to avoid overloading your RPC.
-	 * @returns Promise<boolean> : SubscriptionSuccess
-	 */
-	public async subscribe(
-		optionalSubscriptions?: ClearingHouseAccountTypes[]
-	): Promise<boolean> {
-		this.isSubscribed = await this.accountSubscriber.subscribe(
-			optionalSubscriptions
+	createUsers(
+		userIds: number[],
+		accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig
+	): void {
+		for (const userId of userIds) {
+			const user = this.createUser(userId, accountSubscriptionConfig);
+			this.users.set(userId, user);
+		}
+	}
+
+	createUser(
+		userId: number,
+		accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig
+	): ClearingHouseUser {
+		const userAccountPublicKey = getUserAccountPublicKeySync(
+			this.program.programId,
+			this.wallet.publicKey,
+			userId
+		);
+
+		return new ClearingHouseUser({
+			clearingHouse: this,
+			userAccountPublicKey,
+			accountSubscription: accountSubscriptionConfig,
+		});
+	}
+
+	public async subscribe(): Promise<boolean> {
+		const subscribePromises = this.subscribeUsers().concat(
+			this.accountSubscriber.subscribe()
+		);
+		this.isSubscribed = (await Promise.all(subscribePromises)).reduce(
+			(success, prevSuccess) => success && prevSuccess
 		);
 		return this.isSubscribed;
 	}
 
-	/**
-	 * Shorthand function to subscribe to all available Clearing House State Accounts
-	 * @returns Promise<boolean> : SubscriptionSuccess
-	 */
-	public async subscribeToAll(): Promise<boolean> {
-		return this.subscribe([
-			'curveHistoryAccount',
-			'depositHistoryAccount',
-			'fundingPaymentHistoryAccount',
-			'fundingRateHistoryAccount',
-			'liquidationHistoryAccount',
-			'tradeHistoryAccount',
-			'orderHistoryAccount',
-		]);
+	subscribeUsers(): Promise<boolean>[] {
+		return [...this.users.values()].map((user) => user.subscribe());
 	}
 
 	/**
 	 *	Forces the accountSubscriber to fetch account updates from rpc
 	 */
 	public async fetchAccounts(): Promise<void> {
-		await this.accountSubscriber.fetch();
+		await Promise.all(
+			[...this.users.values()]
+				.map((user) => user.fetchAccounts())
+				.concat(this.accountSubscriber.fetch())
+		);
 	}
 
-	/**
-	 * Unsubscribe from all currently subscribed state accounts
-	 */
 	public async unsubscribe(): Promise<void> {
-		await this.accountSubscriber.unsubscribe();
+		const unsubscribePromises = this.unsubscribeUsers().concat(
+			this.accountSubscriber.unsubscribe()
+		);
+		await Promise.all(unsubscribePromises);
 		this.isSubscribed = false;
 	}
 
+	unsubscribeUsers(): Promise<void>[] {
+		return [...this.users.values()].map((user) => user.unsubscribe());
+	}
+
 	statePublicKey?: PublicKey;
 	public async getStatePublicKey(): Promise<PublicKey> {
 		if (this.statePublicKey) {
@@ -193,75 +228,47 @@ export class ClearingHouse {
 	}
 
 	public getStateAccount(): StateAccount {
-		return this.accountSubscriber.getStateAccount();
-	}
-
-	public async getSettlementAccount(): Promise<SettlementStateAccount> {
-		// @ts-ignore
-		return await this.program.account.settlementState.fetch(
-			await getSettlementStatePublicKey(this.program.programId)
-		);
-	}
-
-	public getMarketsAccount(): MarketsAccount {
-		return this.accountSubscriber.getMarketsAccount();
-	}
-
-	public getMarket(marketIndex: BN | number): Market {
-		if (marketIndex instanceof BN) {
-			marketIndex = marketIndex.toNumber();
-		}
-		return this.getMarketsAccount().markets[marketIndex];
-	}
-
-	public getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount {
-		return this.accountSubscriber.getFundingPaymentHistoryAccount();
-	}
-
-	public getFundingRateHistoryAccount(): FundingRateHistoryAccount {
-		return this.accountSubscriber.getFundingRateHistoryAccount();
-	}
-
-	public getTradeHistoryAccount(): TradeHistoryAccount {
-		return this.accountSubscriber.getTradeHistoryAccount();
-	}
-
-	public getLiquidationHistoryAccount(): LiquidationHistoryAccount {
-		return this.accountSubscriber.getLiquidationHistoryAccount();
+		return this.accountSubscriber.getStateAccountAndSlot().data;
 	}
 
-	public getDepositHistoryAccount(): DepositHistoryAccount {
-		return this.accountSubscriber.getDepositHistoryAccount();
+	public getMarketAccount(marketIndex: BN | number): MarketAccount | undefined {
+		marketIndex = marketIndex instanceof BN ? marketIndex : new BN(marketIndex);
+		return this.accountSubscriber.getMarketAccountAndSlot(marketIndex)?.data;
 	}
 
-	public getCurveHistoryAccount(): ExtendedCurveHistoryAccount {
-		return this.accountSubscriber.getCurveHistoryAccount();
+	public getMarketAccounts(): MarketAccount[] {
+		return this.accountSubscriber
+			.getMarketAccountsAndSlots()
+			.map((value) => value.data);
 	}
 
-	public getOrderHistoryAccount(): OrderHistoryAccount {
-		return this.accountSubscriber.getOrderHistoryAccount();
+	public getBankAccount(bankIndex: BN | number): BankAccount | undefined {
+		bankIndex = bankIndex instanceof BN ? bankIndex : new BN(bankIndex);
+		return this.accountSubscriber.getBankAccountAndSlot(bankIndex).data;
 	}
 
-	orderStatePublicKey?: PublicKey;
-	public async getOrderStatePublicKey(): Promise<PublicKey> {
-		if (this.orderStatePublicKey) {
-			return this.orderStatePublicKey;
-		}
-		this.orderStatePublicKey = await getOrderStateAccountPublicKey(
-			this.program.programId
-		);
-		return this.orderStatePublicKey;
+	public getQuoteAssetBankAccount(): BankAccount {
+		return this.accountSubscriber.getBankAccountAndSlot(QUOTE_ASSET_BANK_INDEX)
+			.data;
 	}
 
-	public getOrderStateAccount(): OrderStateAccount {
-		return this.accountSubscriber.getOrderStateAccount();
+	public getOraclePriceDataAndSlot(
+		oraclePublicKey: PublicKey
+	): DataAndSlot<OraclePriceData> | undefined {
+		return this.accountSubscriber.getOraclePriceDataAndSlot(oraclePublicKey);
 	}
 
 	/**
 	 * Update the wallet to use for clearing house transactions and linked user account
 	 * @param newWallet
+	 * @param userIds
+	 * @param activeUserId
 	 */
-	public updateWallet(newWallet: IWallet): void {
+	public async updateWallet(
+		newWallet: IWallet,
+		userIds = [0],
+		activeUserId = 0
+	): Promise<void> {
 		const newProvider = new AnchorProvider(
 			this.connection,
 			newWallet,
@@ -279,257 +286,364 @@ export class ClearingHouse {
 		this.wallet = newWallet;
 		this.provider = newProvider;
 		this.program = newProgram;
-		this.userAccountPublicKey = undefined;
-		this.userAccount = undefined;
-		this.userOrdersAccountPublicKey = undefined;
-		this.userOrdersExist = undefined;
-	}
 
-	public async initializeUserAccount(): Promise<
-		[TransactionSignature, PublicKey]
-	> {
-		const [
-			userPositionsAccount,
-			userAccountPublicKey,
-			initializeUserAccountIx,
-			initializeUserOrdersAccountIx,
-		] = await this.getInitializeUserInstructions();
+		if (this.isSubscribed) {
+			await Promise.all(this.unsubscribeUsers());
+		}
+		this.users.clear();
+		this.createUsers(userIds, this.userAccountSubscriptionConfig);
+		if (this.isSubscribed) {
+			await Promise.all(this.subscribeUsers());
+		}
 
-		const tx = new Transaction()
-			.add(initializeUserAccountIx)
-			.add(initializeUserOrdersAccountIx);
-		const txSig = await this.txSender.send(
-			tx,
-			[userPositionsAccount],
-			this.opts
-		);
-		return [txSig, userAccountPublicKey];
+		this.activeUserId = activeUserId;
 	}
 
-	async getInitializeUserInstructions(): Promise<
-		[Keypair, PublicKey, TransactionInstruction, TransactionInstruction]
-	> {
-		const [userAccountPublicKey, userAccountNonce] =
-			await getUserAccountPublicKeyAndNonce(
-				this.program.programId,
-				this.wallet.publicKey
-			);
-
-		const remainingAccounts = [];
-		const optionalAccounts = {
-			whitelistToken: false,
-		};
+	public async switchActiveUser(userId: number): Promise<void> {
+		this.activeUserId = userId;
+	}
 
-		const state = this.getStateAccount();
-		if (state.whitelistMint) {
-			optionalAccounts.whitelistToken = true;
-			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,
-			});
+	public async addUser(userId: number): Promise<void> {
+		if (this.users.has(userId)) {
+			return;
 		}
 
-		const userPositions = new Keypair();
-		const initializeUserAccountIx =
-			await this.program.instruction.initializeUser(
-				userAccountNonce,
-				optionalAccounts,
-				{
-					accounts: {
-						user: userAccountPublicKey,
-						authority: this.wallet.publicKey,
-						rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-						systemProgram: anchor.web3.SystemProgram.programId,
-						userPositions: userPositions.publicKey,
-						state: await this.getStatePublicKey(),
-					},
-					remainingAccounts: remainingAccounts,
-				}
-			);
+		const user = this.createUser(userId, this.userAccountSubscriptionConfig);
+		await user.subscribe();
+		this.users.set(userId, user);
+	}
 
-		const initializeUserOrdersAccountIx =
-			await this.getInitializeUserOrdersInstruction(userAccountPublicKey);
+	public async initializeUserAccount(
+		userId = 0,
+		name = DEFAULT_USER_NAME
+	): Promise<[TransactionSignature, PublicKey]> {
+		const [userAccountPublicKey, initializeUserAccountIx] =
+			await this.getInitializeUserInstructions(userId, name);
 
-		return [
-			userPositions,
-			userAccountPublicKey,
-			initializeUserAccountIx,
-			initializeUserOrdersAccountIx,
-		];
+		const tx = new Transaction().add(initializeUserAccountIx);
+		const { txSig } = await this.txSender.send(tx, [], this.opts);
+		return [txSig, userAccountPublicKey];
 	}
 
-	async getInitializeUserOrdersInstruction(
-		userAccountPublicKey?: PublicKey
-	): Promise<TransactionInstruction> {
-		if (!userAccountPublicKey) {
-			userAccountPublicKey = await this.getUserAccountPublicKey();
-		}
-
-		const [userOrdersAccountPublicKey, userOrdersAccountNonce] =
-			await getUserOrdersAccountPublicKeyAndNonce(
-				this.program.programId,
-				userAccountPublicKey
-			);
+	async getInitializeUserInstructions(
+		userId = 0,
+		name = DEFAULT_USER_NAME
+	): Promise<[PublicKey, TransactionInstruction]> {
+		const userAccountPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			userId
+		);
 
-		return await this.program.instruction.initializeUserOrders(
-			userOrdersAccountNonce,
-			{
+		const nameBuffer = encodeName(name);
+		const initializeUserAccountIx =
+			await this.program.instruction.initializeUser(userId, nameBuffer, {
 				accounts: {
 					user: userAccountPublicKey,
 					authority: this.wallet.publicKey,
+					payer: this.wallet.publicKey,
 					rent: anchor.web3.SYSVAR_RENT_PUBKEY,
 					systemProgram: anchor.web3.SystemProgram.programId,
-					userOrders: userOrdersAccountPublicKey,
 					state: await this.getStatePublicKey(),
 				},
-			}
-		);
+			});
+
+		return [userAccountPublicKey, initializeUserAccountIx];
 	}
 
-	userAccountPublicKey?: PublicKey;
-	/**
-	 * Get the address for the Clearing House User's account. NOT the user's wallet address.
-	 * @returns
-	 */
-	public async getUserAccountPublicKey(): Promise<PublicKey> {
-		if (this.userAccountPublicKey) {
-			return this.userAccountPublicKey;
+	public getUser(userId?: number): ClearingHouseUser {
+		userId = userId ?? this.activeUserId;
+		if (!this.users.has(userId)) {
+			throw new Error(`Clearing House has no user for user id ${userId}`);
 		}
+		return this.users.get(userId);
+	}
 
-		this.userAccountPublicKey = await getUserAccountPublicKey(
-			this.program.programId,
-			this.wallet.publicKey
-		);
-		return this.userAccountPublicKey;
+	public getUsers(): ClearingHouseUser[] {
+		return [...this.users.values()];
 	}
 
-	userAccount?: UserAccount;
-	public async getUserAccount(): Promise<UserAccount> {
-		if (this.userAccount) {
-			return this.userAccount;
-		}
+	public async getUserAccountPublicKey(): Promise<PublicKey> {
+		return this.getUser().userAccountPublicKey;
+	}
 
-		this.userAccount = (await this.program.account.user.fetch(
-			await this.getUserAccountPublicKey()
-		)) as UserAccount;
-		return this.userAccount;
+	public getUserAccount(userId?: number): UserAccount | undefined {
+		return this.getUser(userId).getUserAccount();
 	}
 
-	userOrdersAccountPublicKey?: PublicKey;
-	/**
-	 * Get the address for the Clearing House User Order's account. NOT the user's wallet address.
-	 * @returns
-	 */
-	public async getUserOrdersAccountPublicKey(): Promise<PublicKey> {
-		if (this.userOrdersAccountPublicKey) {
-			return this.userOrdersAccountPublicKey;
-		}
+	public getUserAccountAndSlot(
+		userId?: number
+	): DataAndSlot<UserAccount> | undefined {
+		return this.getUser(userId).getUserAccountAndSlot();
+	}
 
-		this.userOrdersAccountPublicKey = await getUserOrdersAccountPublicKey(
-			this.program.programId,
-			await this.getUserAccountPublicKey()
+	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 getQuoteAssetTokenAmount(): BN {
+		const bank = this.getBankAccount(QUOTE_ASSET_BANK_INDEX);
+		const userBankBalance = this.getUserBankBalance(QUOTE_ASSET_BANK_INDEX);
+		return getTokenAmount(
+			userBankBalance.balance,
+			bank,
+			userBankBalance.balanceType
 		);
-		return this.userOrdersAccountPublicKey;
 	}
 
-	userOrdersExist?: boolean;
-	async userOrdersAccountExists(): Promise<boolean> {
-		if (this.userOrdersExist) {
-			return this.userOrdersExist;
+	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;
+
+		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);
+			}
+		}
+
+		for (const position of userAccount.positions) {
+			if (!positionIsAvailable(position)) {
+				const marketIndexNum = position.marketIndex.toNumber();
+				const marketAccount = this.getMarketAccount(marketIndexNum);
+				marketAccountMap.set(marketIndexNum, {
+					pubkey: marketAccount.pubkey,
+					isSigner: false,
+					// isWritable: false, // TODO
+					isWritable: true,
+				});
+				oracleAccountMap.set(marketAccount.pubkey.toString(), {
+					pubkey: marketAccount.amm.oracle,
+					isSigner: false,
+					isWritable: false,
+				});
+			}
 		}
-		const userOrdersAccountRPCResponse =
-			await this.connection.getParsedAccountInfo(
-				await this.getUserOrdersAccountPublicKey()
+
+		if (params.writableMarketIndex) {
+			const marketAccount = this.getMarketAccount(
+				params.writableMarketIndex.toNumber()
 			);
+			marketAccountMap.set(params.writableMarketIndex.toNumber(), {
+				pubkey: marketAccount.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
+			oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+				pubkey: marketAccount.amm.oracle,
+				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,
+					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,
+					isSigner: false,
+					isWritable: false,
+				});
+			}
+		}
+
+		return [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.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)
+		);
+	}
 
-		this.userOrdersExist = userOrdersAccountRPCResponse.value !== null;
-		return this.userOrdersExist;
+	public getOrderByUserId(userOrderId: number): Order | undefined {
+		return this.getUserAccount()?.orders.find(
+			(order) => order.userOrderId === userOrderId
+		);
 	}
 
-	public async depositCollateral(
+	public async deposit(
 		amount: BN,
+		bankIndex: BN,
 		collateralAccountPublicKey: PublicKey,
-		userPositionsAccountPublicKey?: PublicKey
+		userId?: number,
+		reduceOnly = false
 	): Promise<TransactionSignature> {
-		const depositCollateralIx = await this.getDepositCollateralInstruction(
+		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
+			bankIndex,
 			collateralAccountPublicKey,
-			userPositionsAccountPublicKey
+			userId,
+			reduceOnly,
+			true
 		);
 
 		const tx = new Transaction().add(depositCollateralIx);
 
-		return await this.txSender.send(tx);
+		const { txSig } = await this.txSender.send(tx);
+		return txSig;
 	}
 
-	async getDepositCollateralInstruction(
+	async getDepositInstruction(
 		amount: BN,
-		collateralAccountPublicKey: PublicKey,
-		userPositionsAccountPublicKey?: PublicKey
+		bankIndex: BN,
+		userTokenAccount: PublicKey,
+		userId?: number,
+		reduceOnly = false,
+		userInitialized = true
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		if (!userPositionsAccountPublicKey) {
-			userPositionsAccountPublicKey = (await this.getUserAccount()).positions;
+		const userAccountPublicKey = userId
+			? await getUserAccountPublicKey(
+					this.program.programId,
+					this.wallet.publicKey,
+					userId
+			  )
+			: await this.getUserAccountPublicKey();
+
+		let remainingAccounts = [];
+		if (userInitialized) {
+			remainingAccounts = this.getRemainingAccounts({
+				writableBankIndex: bankIndex,
+			});
+		} else {
+			const bankAccount = this.getBankAccount(bankIndex);
+			if (!bankAccount.oracle.equals(PublicKey.default)) {
+				remainingAccounts.push({
+					pubkey: bankAccount.oracle,
+					isSigner: false,
+					isWritable: false,
+				});
+			}
+			remainingAccounts.push({
+				pubkey: bankAccount.pubkey,
+				isSigner: false,
+				isWritable: true,
+			});
 		}
 
-		const state = this.getStateAccount();
-		return await this.program.instruction.depositCollateral(amount, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
-				collateralVault: state.collateralVault,
-				userCollateralAccount: collateralAccountPublicKey,
-				authority: this.wallet.publicKey,
-				tokenProgram: TOKEN_PROGRAM_ID,
-				markets: state.markets,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				depositHistory: state.depositHistory,
-				userPositions: userPositionsAccountPublicKey,
-			},
-		});
+		const bank = this.getBankAccount(bankIndex);
+
+		return await this.program.instruction.deposit(
+			bankIndex,
+			amount,
+			reduceOnly,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					bank: bank.pubkey,
+					bankVault: bank.vault,
+					user: userAccountPublicKey,
+					userTokenAccount: userTokenAccount,
+					authority: this.wallet.publicKey,
+					tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts,
+			}
+		);
 	}
 
 	/**
 	 * Creates the Clearing House User account for a user, and deposits some initial collateral
+	 * @param userId
+	 * @param name
 	 * @param amount
-	 * @param collateralAccountPublicKey
+	 * @param userTokenAccount
+	 * @param fromUserId
 	 * @returns
 	 */
 	public async initializeUserAccountAndDepositCollateral(
 		amount: BN,
-		collateralAccountPublicKey: PublicKey
+		userTokenAccount: PublicKey,
+		bankIndex = new BN(0),
+		userId = 0,
+		name = DEFAULT_USER_NAME,
+		fromUserId?: number
 	): Promise<[TransactionSignature, PublicKey]> {
-		const [
-			userPositionsAccount,
-			userAccountPublicKey,
-			initializeUserAccountIx,
-			initializeUserOrdersAccountIx,
-		] = await this.getInitializeUserInstructions();
-
-		const depositCollateralIx = await this.getDepositCollateralInstruction(
-			amount,
-			collateralAccountPublicKey,
-			userPositionsAccount.publicKey
-		);
+		const [userAccountPublicKey, initializeUserAccountIx] =
+			await this.getInitializeUserInstructions(userId, name);
+
+		const depositCollateralIx =
+			fromUserId != null
+				? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
+				: await this.getDepositInstruction(
+						amount,
+						bankIndex,
+						userTokenAccount,
+						userId,
+						false,
+						false
+				  );
 
 		const tx = new Transaction()
 			.add(initializeUserAccountIx)
-			.add(initializeUserOrdersAccountIx)
 			.add(depositCollateralIx);
 
-		const txSig = await this.txSender.send(tx, [userPositionsAccount]);
+		const { txSig } = await this.txSender.send(tx, []);
 
 		return [txSig, userAccountPublicKey];
 	}
 
 	public async initializeUserAccountForDevnet(
+		userId = 0,
+		name = DEFAULT_USER_NAME,
 		mockUSDCFaucet: MockUSDCFaucet,
 		amount: BN
 	): Promise<[TransactionSignature, PublicKey]> {
@@ -539,826 +653,806 @@ export class ClearingHouse {
 				amount
 			);
 
-		const [
-			userPositionsAccount,
-			userAccountPublicKey,
-			initializeUserAccountIx,
-			initializeUserOrdersAccountIx,
-		] = await this.getInitializeUserInstructions();
+		const [userAccountPublicKey, initializeUserAccountIx] =
+			await this.getInitializeUserInstructions(userId, name);
 
-		const depositCollateralIx = await this.getDepositCollateralInstruction(
+		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
+			new BN(0),
 			associateTokenPublicKey,
-			userPositionsAccount.publicKey
+			userId,
+			false,
+			false
 		);
 
 		const tx = new Transaction()
 			.add(createAssociatedAccountIx)
 			.add(mintToIx)
 			.add(initializeUserAccountIx)
-			.add(initializeUserOrdersAccountIx)
 			.add(depositCollateralIx);
 
-		const txSig = await this.program.provider.sendAndConfirm(tx, [
-			userPositionsAccount,
-		]);
+		const txSig = await this.program.provider.sendAndConfirm(tx, []);
 
 		return [txSig, userAccountPublicKey];
 	}
 
-	public async withdrawCollateral(
-		amount: BN,
-		collateralAccountPublicKey: PublicKey
-	): Promise<TransactionSignature> {
-		return this.txSender.send(
-			wrapInTx(
-				await this.getWithdrawCollateralIx(amount, collateralAccountPublicKey)
-			),
-			[],
-			this.opts
-		);
-	}
-
-	public async getWithdrawCollateralIx(
-		amount: BN,
-		collateralAccountPublicKey: PublicKey
-	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const user: any = await this.program.account.user.fetch(
-			userAccountPublicKey
-		);
-
-		const state = this.getStateAccount();
-		return await this.program.instruction.withdrawCollateral(amount, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
-				collateralVault: state.collateralVault,
-				collateralVaultAuthority: state.collateralVaultAuthority,
-				insuranceVault: state.insuranceVault,
-				insuranceVaultAuthority: state.insuranceVaultAuthority,
-				userCollateralAccount: collateralAccountPublicKey,
-				authority: this.wallet.publicKey,
-				tokenProgram: TOKEN_PROGRAM_ID,
-				markets: state.markets,
-				userPositions: user.positions,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				depositHistory: state.depositHistory,
-			},
-		});
-	}
-
-	public async openPosition(
-		direction: PositionDirection,
+	public async withdraw(
 		amount: BN,
-		marketIndex: BN,
-		limitPrice?: BN,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+		bankIndex: BN,
+		userTokenAccount: PublicKey,
+		reduceOnly = false
 	): Promise<TransactionSignature> {
-		return await this.txSender.send(
+		const { txSig } = await this.txSender.send(
 			wrapInTx(
-				await this.getOpenPositionIx(
-					direction,
+				await this.getWithdrawIx(
 					amount,
-					marketIndex,
-					limitPrice,
-					discountToken,
-					referrer
+					bankIndex,
+					userTokenAccount,
+					reduceOnly
 				)
 			),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
-	public async getOpenPositionIx(
-		direction: PositionDirection,
+	public async getWithdrawIx(
 		amount: BN,
-		marketIndex: BN,
-		limitPrice?: BN,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+		bankIndex: BN,
+		userTokenAccount: PublicKey,
+		reduceOnly = false
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
 
-		if (limitPrice == undefined) {
-			limitPrice = new BN(0); // no limit
-		}
-
-		const optionalAccounts = {
-			discountToken: false,
-			referrer: false,
-		};
-		const remainingAccounts = [];
-		if (discountToken) {
-			optionalAccounts.discountToken = true;
-			remainingAccounts.push({
-				pubkey: discountToken,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
-		if (referrer) {
-			optionalAccounts.referrer = true;
-			remainingAccounts.push({
-				pubkey: referrer,
-				isWritable: true,
-				isSigner: false,
-			});
-		}
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
 
-		const priceOracle =
-			this.getMarketsAccount().markets[marketIndex.toNumber()].amm.oracle;
+		const bank = this.getBankAccount(bankIndex);
 
-		const state = this.getStateAccount();
-		return await this.program.instruction.openPosition(
-			direction,
+		return await this.program.instruction.withdraw(
+			bankIndex,
 			amount,
-			marketIndex,
-			limitPrice,
-			optionalAccounts,
+			reduceOnly,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
+					bank: bank.pubkey,
+					bankVault: bank.vault,
+					bankVaultAuthority: bank.vaultAuthority,
 					user: userAccountPublicKey,
+					userTokenAccount: userTokenAccount,
 					authority: this.wallet.publicKey,
-					markets: state.markets,
-					userPositions: userAccount.positions,
-					tradeHistory: state.tradeHistory,
-					fundingPaymentHistory: state.fundingPaymentHistory,
-					fundingRateHistory: state.fundingRateHistory,
-					oracle: priceOracle,
+					tokenProgram: TOKEN_PROGRAM_ID,
 				},
-				remainingAccounts: remainingAccounts,
+				remainingAccounts,
 			}
 		);
 	}
 
-	public async initializeUserOrdersThenPlaceOrder(
-		orderParams: OrderParams,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async transferDeposit(
+		amount: BN,
+		bankIndex: BN,
+		fromUserId: number,
+		toUserId: number
 	): Promise<TransactionSignature> {
-		const instructions: anchor.web3.TransactionInstruction[] = [];
-		const userOrdersAccountExists = await this.userOrdersAccountExists();
-		if (!userOrdersAccountExists) {
-			instructions.push(await this.getInitializeUserOrdersInstruction());
-		}
-		instructions.push(
-			await this.getPlaceOrderIx(orderParams, discountToken, referrer)
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getTransferDepositIx(amount, bankIndex, fromUserId, toUserId)
+			),
+			[],
+			this.opts
 		);
-		const tx = new Transaction();
-		for (const instruction of instructions) {
-			tx.add(instruction);
-		}
-
-		return await this.txSender.send(tx, [], this.opts);
+		return txSig;
 	}
 
-	public async placeOrder(
-		orderParams: OrderParams,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
-	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(
-				await this.getPlaceOrderIx(orderParams, discountToken, referrer)
-			),
-			[],
-			this.opts
-		);
-	}
-
-	public async getPlaceOrderIx(
-		orderParams: OrderParams,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async getTransferDepositIx(
+		amount: BN,
+		bankIndex: BN,
+		fromUserId: number,
+		toUserId: number
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
-
-		const priceOracle =
-			this.getMarketsAccount().markets[orderParams.marketIndex.toNumber()].amm
-				.oracle;
-
-		const remainingAccounts = [];
-		if (orderParams.optionalAccounts.discountToken) {
-			if (!discountToken) {
-				throw Error(
-					'Optional accounts specified discount token but no discount token present'
-				);
-			}
-
-			remainingAccounts.push({
-				pubkey: discountToken,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
-
-		if (orderParams.optionalAccounts.referrer) {
-			if (!referrer) {
-				throw Error(
-					'Optional accounts specified referrer but no referrer present'
-				);
-			}
-
-			remainingAccounts.push({
-				pubkey: referrer,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
+		const fromUser = await getUserAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			fromUserId
+		);
+		const toUser = await getUserAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			toUserId
+		);
 
-		if (!orderParams.oraclePriceOffset.eq(ZERO)) {
-			remainingAccounts.push({
-				pubkey: priceOracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
 
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
-		return await this.program.instruction.placeOrder(orderParams, {
+		return await this.program.instruction.transferDeposit(bankIndex, amount, {
 			accounts: {
-				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				markets: state.markets,
-				userOrders: await this.getUserOrdersAccountPublicKey(),
-				userPositions: userAccount.positions,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				fundingRateHistory: state.fundingRateHistory,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
+				fromUser,
+				toUser,
+				state: await this.getStatePublicKey(),
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async expireOrders(
-		userAccountPublicKey: PublicKey,
-		userOrdersAccountPublicKey: PublicKey
+	public async updateBankCumulativeInterest(
+		bankIndex: BN
 	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(
-				await this.getExpireOrdersIx(
-					userAccountPublicKey,
-					userOrdersAccountPublicKey
-				)
-			),
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.updateBankCumulativeInterestIx(bankIndex)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
-	public async getExpireOrdersIx(
-		userAccountPublicKey: PublicKey,
-		userOrdersAccountPublicKey: PublicKey
+	public async updateBankCumulativeInterestIx(
+		bankIndex: BN
 	): Promise<TransactionInstruction> {
-		const fillerPublicKey = await this.getUserAccountPublicKey();
-		const userAccount: any = await this.program.account.user.fetch(
-			userAccountPublicKey
-		);
-
-		const orderState = this.getOrderStateAccount();
-		return await this.program.instruction.expireOrders({
+		const bank = this.getBankAccount(bankIndex);
+		return await this.program.instruction.updateBankCumulativeInterest({
 			accounts: {
-				state: await this.getStatePublicKey(),
-				filler: fillerPublicKey,
-				user: userAccountPublicKey,
-				authority: this.wallet.publicKey,
-				userPositions: userAccount.positions,
-				userOrders: userOrdersAccountPublicKey,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
+				bank: bank.pubkey,
 			},
 		});
 	}
 
-	public async cancelOrder(
-		orderId: BN,
-		oracle?: PublicKey
+	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> {
-		return await this.txSender.send(
-			wrapInTx(await this.getCancelOrderIx(orderId, oracle)),
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getPlaceOrderIx(orderParams)),
 			[],
 			this.opts
 		);
+		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+		return txSig;
+	}
+
+	getOrderParams(optionalOrderParams: OptionalOrderParams): OrderParams {
+		return Object.assign({}, DefaultOrderParams, optionalOrderParams);
 	}
 
-	public async getCancelOrderIx(
-		orderId: BN,
-		oracle?: PublicKey
+	public async getPlaceOrderIx(
+		orderParams: OptionalOrderParams
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
-
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
 
-		const remainingAccounts = [];
-		if (oracle) {
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: orderParams.marketIndex,
+		});
 
-		return await this.program.instruction.cancelOrder(orderId, {
+		return await this.program.instruction.placeOrder(orderParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				markets: state.markets,
-				userOrders: await this.getUserOrdersAccountPublicKey(),
-				userPositions: userAccount.positions,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				fundingRateHistory: state.fundingRateHistory,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async cancelOrderByUserId(
-		userOrderId: number,
-		oracle?: PublicKey
-	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(await this.getCancelOrderByUserIdIx(userOrderId, oracle)),
+	public async updateAMMs(marketIndexes: BN[]): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getUpdateAMMsIx(marketIndexes)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
-	public async getCancelOrderByUserIdIx(
-		userOrderId: number,
-		oracle?: PublicKey
+	public async getUpdateAMMsIx(
+		marketIndexes: BN[]
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
-
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
-
-		const remainingAccounts = [];
-		if (oracle) {
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
+		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,
-				markets: state.markets,
-				userOrders: await this.getUserOrdersAccountPublicKey(),
-				userPositions: userAccount.positions,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				fundingRateHistory: state.fundingRateHistory,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async cancelAllOrders(
-		oracles?: PublicKey[],
-		bestEffort?: boolean
-	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(await this.getCancelAllOrdersIx(oracles, bestEffort)),
+	public async cancelOrder(orderId?: BN): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getCancelOrderIx(orderId)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
-	public async getCancelAllOrdersIx(
-		oracles: PublicKey[],
-		bestEffort?: boolean
-	): Promise<TransactionInstruction> {
+	public async getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
 
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
-
-		const remainingAccounts = [];
-		for (const oracle of oracles) {
-			remainingAccounts.push({
-				pubkey: oracle,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
+		const remainingAccounts = this.getRemainingAccounts({});
 
-		return await this.program.instruction.cancelAllOrders(bestEffort, {
+		return await this.program.instruction.cancelOrder(orderId ?? null, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				markets: state.markets,
-				userOrders: await this.getUserOrdersAccountPublicKey(),
-				userPositions: userAccount.positions,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				fundingRateHistory: state.fundingRateHistory,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async cancelOrdersByMarketAndSide(
-		oracles?: PublicKey[],
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
+	public async cancelOrderByUserId(
+		userOrderId: number
 	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(
-				await this.getCancelOrdersByMarketAndSideIx(
-					oracles,
-					bestEffort,
-					marketIndexOnly,
-					directionOnly
-				)
-			),
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getCancelOrderByUserIdIx(userOrderId)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
-	public async getCancelOrdersByMarketAndSideIx(
-		oracles: PublicKey[],
-		bestEffort?: boolean,
-		marketIndexOnly?: BN,
-		directionOnly?: PositionDirection
+	public async getCancelOrderByUserIdIx(
+		userOrderId: number
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
 
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
+		const order = this.getOrderByUserId(userOrderId);
+		const oracle = this.getMarketAccount(order.marketIndex).amm.oracle;
 
-		const remainingAccounts = [];
-		for (const oracle of oracles) {
-			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,
-					markets: state.markets,
-					userOrders: await this.getUserOrdersAccountPublicKey(),
-					userPositions: userAccount.positions,
-					fundingPaymentHistory: state.fundingPaymentHistory,
-					fundingRateHistory: state.fundingRateHistory,
-					orderState: await this.getOrderStatePublicKey(),
-					orderHistory: orderState.orderHistory,
-				},
-				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,
-		userOrdersAccountPublicKey: PublicKey,
-		order: Order
+		user: UserAccount,
+		order?: Order,
+		makerInfo?: MakerInfo
 	): Promise<TransactionSignature> {
-		return await this.txSender.send(
+		const { txSig } = await this.txSender.send(
 			wrapInTx(
-				await this.getFillOrderIx(
-					userAccountPublicKey,
-					userOrdersAccountPublicKey,
-					order
-				)
+				await this.getFillOrderIx(userAccountPublicKey, user, order, makerInfo)
 			),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
 	public async getFillOrderIx(
 		userAccountPublicKey: PublicKey,
-		userOrdersAccountPublicKey: PublicKey,
-		order: Order
+		userAccount: UserAccount,
+		order: Order,
+		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
 		const fillerPublicKey = await this.getUserAccountPublicKey();
-		const userAccount: any = await this.program.account.user.fetch(
-			userAccountPublicKey
-		);
 
 		const marketIndex = order.marketIndex;
-		const oracle = this.getMarket(marketIndex).amm.oracle;
+		const marketAccount = this.getMarketAccount(marketIndex);
 
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
 
-		const remainingAccounts = [];
-		if (!order.referrer.equals(PublicKey.default)) {
+		marketAccountMap.set(marketIndex.toNumber(), {
+			pubkey: marketAccount.pubkey,
+			isWritable: true,
+			isSigner: false,
+		});
+		oracleAccountMap.set(marketAccount.amm.oracle.toString(), {
+			pubkey: marketAccount.amm.oracle,
+			isWritable: false,
+			isSigner: false,
+		});
+
+		for (const bankBalance of userAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
+			}
+		}
+
+		for (const position of userAccount.positions) {
+			if (
+				!positionIsAvailable(position) &&
+				!position.marketIndex.eq(order.marketIndex)
+			) {
+				const market = this.getMarketAccount(position.marketIndex);
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: true,
+					isSigner: false,
+				});
+				oracleAccountMap.set(market.amm.oracle.toString(), {
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+
+		const remainingAccounts = [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
+
+		if (makerInfo) {
 			remainingAccounts.push({
-				pubkey: order.referrer,
+				pubkey: makerInfo.maker,
 				isWritable: true,
 				isSigner: false,
 			});
 		}
 
 		const orderId = order.orderId;
-		return await this.program.instruction.fillOrder(orderId, {
+		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
+
+		return await this.program.instruction.fillOrder(orderId, makerOrderId, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,
 				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
-				markets: state.markets,
-				userPositions: userAccount.positions,
-				userOrders: userOrdersAccountPublicKey,
-				tradeHistory: state.tradeHistory,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				fundingRateHistory: state.fundingRateHistory,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
-				extendedCurveHistory: state.extendedCurveHistory,
-				oracle: oracle,
 			},
 			remainingAccounts,
 		});
 	}
 
-	public async initializeUserOrdersThenPlaceAndFillOrder(
-		orderParams: OrderParams,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
-	): Promise<TransactionSignature> {
-		const instructions: anchor.web3.TransactionInstruction[] = [];
-		const userOrdersAccountExists = await this.userOrdersAccountExists();
-		if (!userOrdersAccountExists) {
-			instructions.push(await this.getInitializeUserOrdersInstruction());
-		}
-		instructions.push(
-			await this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer)
-		);
-		const tx = new Transaction();
-		for (const instruction of instructions) {
-			tx.add(instruction);
-		}
-
-		return await this.txSender.send(tx, [], this.opts);
-	}
-
-	public async placeAndFillOrder(
-		orderParams: OrderParams,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async triggerOrder(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		order: Order
 	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(
-				await this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer)
-			),
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getTriggerOrderIx(userAccountPublicKey, user, order)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
-	public async getPlaceAndFillOrderIx(
-		orderParams: OrderParams,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async getTriggerOrderIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		order: Order
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
+		const fillerPublicKey = await this.getUserAccountPublicKey();
 
-		const priceOracle =
-			this.getMarketsAccount().markets[orderParams.marketIndex.toNumber()].amm
-				.oracle;
+		const marketIndex = order.marketIndex;
+		const marketAccount = this.getMarketAccount(marketIndex);
 
-		const remainingAccounts = [];
-		if (orderParams.optionalAccounts.discountToken) {
-			if (!discountToken) {
-				throw Error(
-					'Optional accounts specified discount token but no discount token present'
-				);
-			}
+		const oracleAccountMap = new Map<string, AccountMeta>();
+		const bankAccountMap = new Map<number, AccountMeta>();
+		const marketAccountMap = new Map<number, AccountMeta>();
 
-			remainingAccounts.push({
-				pubkey: discountToken,
-				isWritable: false,
-				isSigner: false,
-			});
-		}
+		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,
+		});
 
-		if (orderParams.optionalAccounts.referrer) {
-			if (!referrer) {
-				throw Error(
-					'Optional accounts specified referrer but no referrer present'
-				);
+		for (const bankBalance of userAccount.bankBalances) {
+			if (!bankBalance.balance.eq(ZERO)) {
+				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
+				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
+					pubkey: bankAccount.pubkey,
+					isSigner: false,
+					isWritable: true,
+				});
+
+				if (!bankAccount.oracle.equals(PublicKey.default)) {
+					oracleAccountMap.set(bankAccount.oracle.toString(), {
+						pubkey: bankAccount.oracle,
+						isSigner: false,
+						isWritable: false,
+					});
+				}
 			}
+		}
 
-			remainingAccounts.push({
-				pubkey: referrer,
-				isWritable: true,
-				isSigner: false,
-			});
+		for (const position of userAccount.positions) {
+			if (
+				!positionIsAvailable(position) &&
+				!position.marketIndex.eq(order.marketIndex)
+			) {
+				const market = this.getMarketAccount(position.marketIndex);
+				marketAccountMap.set(position.marketIndex.toNumber(), {
+					pubkey: market.pubkey,
+					isWritable: true,
+					isSigner: false,
+				});
+				oracleAccountMap.set(market.amm.oracle.toString(), {
+					pubkey: market.amm.oracle,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
 		}
 
-		const state = this.getStateAccount();
-		const orderState = this.getOrderStateAccount();
-		return await this.program.instruction.placeAndFillOrder(orderParams, {
+		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,
-				markets: state.markets,
-				userOrders: await this.getUserOrdersAccountPublicKey(),
-				userPositions: userAccount.positions,
-				tradeHistory: state.tradeHistory,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-				fundingRateHistory: state.fundingRateHistory,
-				orderState: await this.getOrderStatePublicKey(),
-				orderHistory: orderState.orderHistory,
-				extendedCurveHistory: state.extendedCurveHistory,
-				oracle: priceOracle,
 			},
 			remainingAccounts,
 		});
 	}
 
-	/**
-	 * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
-	 * @param marketIndex
-	 * @param discountToken
-	 * @param referrer
-	 * @returns
-	 */
-	public async closePosition(
-		marketIndex: BN,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async placeAndTake(
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo
 	): Promise<TransactionSignature> {
-		return await this.txSender.send(
-			wrapInTx(
-				await this.getClosePositionIx(marketIndex, discountToken, referrer)
-			),
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getPlaceAndTakeIx(orderParams, makerInfo)),
 			[],
 			this.opts
 		);
+		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+		return txSig;
 	}
 
-	public async getClosePositionIx(
-		marketIndex: BN,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async getPlaceAndTakeIx(
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const userAccount = await this.getUserAccount();
 
-		const priceOracle =
-			this.getMarketsAccount().markets[marketIndex.toNumber()].amm.oracle;
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: orderParams.marketIndex,
+			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
+		});
 
-		const optionalAccounts = {
-			discountToken: false,
-			referrer: false,
-		};
-		const remainingAccounts = [];
-		if (discountToken) {
-			optionalAccounts.discountToken = true;
+		let makerOrderId = null;
+		if (makerInfo) {
+			makerOrderId = makerInfo.order.orderId;
 			remainingAccounts.push({
-				pubkey: discountToken,
-				isWritable: false,
+				pubkey: makerInfo.maker,
 				isSigner: false,
-			});
-		}
-		if (referrer) {
-			optionalAccounts.referrer = true;
-			remainingAccounts.push({
-				pubkey: referrer,
 				isWritable: true,
-				isSigner: false,
 			});
 		}
 
-		const state = this.getStateAccount();
-		return await this.program.instruction.closePosition(
-			marketIndex,
-			optionalAccounts,
+		return await this.program.instruction.placeAndTake(
+			orderParams,
+			makerOrderId,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
 					authority: this.wallet.publicKey,
-					markets: state.markets,
-					userPositions: userAccount.positions,
-					tradeHistory: state.tradeHistory,
-					fundingPaymentHistory: state.fundingPaymentHistory,
-					fundingRateHistory: state.fundingRateHistory,
-					oracle: priceOracle,
 				},
-				remainingAccounts: remainingAccounts,
+				remainingAccounts,
 			}
 		);
 	}
 
-	public async closeAllPositions(
-		userPositionsAccount: UserPositionsAccount,
-		discountToken?: PublicKey,
-		referrer?: PublicKey
+	public async placeAndMake(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo
 	): Promise<TransactionSignature> {
-		const ixs: TransactionInstruction[] = [];
-		for (const userPosition of userPositionsAccount.positions) {
-			if (userPosition.baseAssetAmount.eq(ZERO)) {
-				continue;
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getPlaceAndMakeIx(orderParams, takerInfo)),
+			[],
+			this.opts
+		);
+
+		this.marketLastSlotCache.set(orderParams.marketIndex.toNumber(), slot);
+
+		return txSig;
+	}
+
+	public async getPlaceAndMakeIx(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams);
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: orderParams.marketIndex,
+			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
+		});
+
+		const takerOrderId = takerInfo!.order!.orderId;
+		remainingAccounts.push({
+			pubkey: takerInfo.taker,
+			isSigner: false,
+			isWritable: true,
+		});
+
+		return await this.program.instruction.placeAndMake(
+			orderParams,
+			takerOrderId,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					taker: takerInfo.taker,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
 			}
+		);
+	}
+
+	/**
+	 * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
+	 * @param marketIndex
+	 * @returns
+	 */
+	public async closePosition(marketIndex: BN): Promise<TransactionSignature> {
+		const userPosition = this.getUser().getUserPosition(marketIndex);
+		if (!userPosition) {
+			throw Error(`No position in market ${marketIndex.toString()}`);
+		}
 
+		return await this.placeAndTake({
+			orderType: OrderType.MARKET,
+			marketIndex,
+			direction: findDirectionToClose(userPosition),
+			baseAssetAmount: userPosition.baseAssetAmount,
+			reduceOnly: true,
+		});
+	}
+
+	public async settlePNLs(
+		users: {
+			settleeUserAccountPublicKey: PublicKey;
+			settleeUserAccount: UserAccount;
+		}[],
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const ixs = [];
+		for (const { settleeUserAccountPublicKey, settleeUserAccount } of users) {
 			ixs.push(
-				await this.getClosePositionIx(
-					userPosition.marketIndex,
-					discountToken,
-					referrer
+				await this.settlePNLIx(
+					settleeUserAccountPublicKey,
+					settleeUserAccount,
+					marketIndex
 				)
 			);
 		}
 
 		const tx = new Transaction().add(...ixs);
 
-		return this.txSender.send(tx, [], this.opts);
+		const { txSig } = await this.txSender.send(tx, [], this.opts);
+		return txSig;
+	}
+
+	public async settlePNL(
+		settleeUserAccountPublicKey: PublicKey,
+		settleeUserAccount: UserAccount,
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.settlePNLIx(
+					settleeUserAccountPublicKey,
+					settleeUserAccount,
+					marketIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async settlePNLIx(
+		settleeUserAccountPublicKey: PublicKey,
+		settleeUserAccount: UserAccount,
+		marketIndex: BN
+	): 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 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,
+		});
+
+		bankAccountMap.set(QUOTE_ASSET_BANK_INDEX.toNumber(), {
+			pubkey: this.getBankAccount(QUOTE_ASSET_BANK_INDEX).pubkey,
+			isSigner: false,
+			isWritable: true,
+		});
+
+		const remainingAccounts = [
+			...oracleAccountMap.values(),
+			...bankAccountMap.values(),
+			...marketAccountMap.values(),
+		];
+
+		return await this.program.instruction.settlePnl(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+				user: settleeUserAccountPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
 	}
 
 	public async liquidate(
 		liquidateeUserAccountPublicKey: PublicKey
 	): Promise<TransactionSignature> {
-		return this.txSender.send(
+		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getLiquidateIx(liquidateeUserAccountPublicKey)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
 	public async getLiquidateIx(
 		liquidateeUserAccountPublicKey: PublicKey
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
-
-		const liquidateeUserAccount: any = await this.program.account.user.fetch(
+		const liquidateeUserAccount = (await this.program.account.user.fetch(
 			liquidateeUserAccountPublicKey
-		);
-		const liquidateePositions: any =
-			await this.program.account.userPositions.fetch(
-				liquidateeUserAccount.positions
-			);
-		const markets = this.getMarketsAccount();
+		)) as UserAccount;
 
-		const remainingAccounts = [];
-		for (const position of liquidateePositions.positions) {
-			if (!position.baseAssetAmount.eq(new BN(0))) {
-				const market = markets.markets[position.marketIndex.toNumber()];
-				remainingAccounts.push({
+		const bankAccountInfos = [
+			{
+				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,
 				});
 			}
 		}
+		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,
-				collateralVault: state.collateralVault,
-				collateralVaultAuthority: state.collateralVaultAuthority,
+				bankVault: quoteAssetBankAccount.vault,
+				bankVaultAuthority: quoteAssetBankAccount.vaultAuthority,
 				insuranceVault: state.insuranceVault,
-				insuranceVaultAuthority: state.insuranceVaultAuthority,
 				tokenProgram: TOKEN_PROGRAM_ID,
-				markets: state.markets,
-				userPositions: liquidateeUserAccount.positions,
-				tradeHistory: state.tradeHistory,
-				liquidationHistory: state.liquidationHistory,
-				fundingPaymentHistory: state.fundingPaymentHistory,
 			},
 			remainingAccounts: remainingAccounts,
 		});
@@ -1368,54 +1462,68 @@ export class ClearingHouse {
 		oracle: PublicKey,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
-		return this.txSender.send(
+		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getUpdateFundingRateIx(oracle, marketIndex)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
 	public async getUpdateFundingRateIx(
 		oracle: PublicKey,
 		marketIndex: BN
 	): Promise<TransactionInstruction> {
-		const state = this.getStateAccount();
 		return await this.program.instruction.updateFundingRate(marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
-				markets: state.markets,
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
 				oracle: oracle,
-				fundingRateHistory: state.fundingRateHistory,
 			},
 		});
 	}
 
 	public async settleFundingPayment(
-		userAccount: PublicKey,
-		userPositionsAccount: PublicKey
+		userAccount: PublicKey
 	): Promise<TransactionSignature> {
-		return this.txSender.send(
-			wrapInTx(
-				await this.getSettleFundingPaymentIx(userAccount, userPositionsAccount)
-			),
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getSettleFundingPaymentIx(userAccount)),
 			[],
 			this.opts
 		);
+		return txSig;
 	}
 
 	public async getSettleFundingPaymentIx(
-		userAccount: PublicKey,
-		userPositionsAccount: PublicKey
+		userAccount: PublicKey
 	): Promise<TransactionInstruction> {
-		const state = this.getStateAccount();
+		const user = (await this.program.account.user.fetch(
+			userAccount
+		)) as UserAccount;
+
+		const userPositions = user.positions;
+
+		const remainingAccounts = [];
+		for (const position of userPositions) {
+			if (!positionIsAvailable(position)) {
+				const marketPublicKey = await getMarketPublicKey(
+					this.program.programId,
+					position.marketIndex
+				);
+				remainingAccounts.push({
+					pubkey: marketPublicKey,
+					isWritable: false,
+					isSigner: false,
+				});
+			}
+		}
+
 		return await this.program.instruction.settleFundingPayment({
 			accounts: {
 				state: await this.getStatePublicKey(),
-				markets: state.markets,
 				user: userAccount,
-				userPositions: userPositionsAccount,
-				fundingPaymentHistory: state.fundingPaymentHistory,
 			},
+			remainingAccounts,
 		});
 	}
 
@@ -1423,121 +1531,10 @@ export class ClearingHouse {
 		this.eventEmitter.emit(eventName, data);
 	}
 
-	public async settlePositionAndClaimCollateral(
-		collateralAccountPublicKey: PublicKey
-	): Promise<TransactionSignature> {
-		const settlePositionIx = await this.getSettlePositionIx();
-		const claimCollateralIx = await this.getClaimCollateralIx(
-			collateralAccountPublicKey
-		);
-		const tx = new Transaction().add(settlePositionIx).add(claimCollateralIx);
-
-		return this.txSender.send(tx, [], this.opts);
-	}
+	public getOracleDataForMarket(marketIndex: BN): OraclePriceData {
+		const oracleKey = this.getMarketAccount(marketIndex).amm.oracle;
+		const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
 
-	public async getSettlePositionIx(): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const user: any = await this.program.account.user.fetch(
-			userAccountPublicKey
-		);
-		const state = this.getStateAccount();
-
-		const settlementState = await getSettlementStatePublicKey(
-			this.program.programId
-		);
-
-		return await this.program.instruction.settlePosition({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
-				markets: state.markets,
-				authority: this.wallet.publicKey,
-				userPositions: user.positions,
-				settlementState,
-				fundingPaymentHistory: state.fundingPaymentHistory,
-			},
-		});
-	}
-
-	public async getClaimCollateralIx(
-		collateralAccountPublicKey: PublicKey
-	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const state = this.getStateAccount();
-
-		const settlementState = await getSettlementStatePublicKey(
-			this.program.programId
-		);
-
-		return await this.program.instruction.claimCollateral({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
-				collateralVault: state.collateralVault,
-				collateralVaultAuthority: state.collateralVaultAuthority,
-				userCollateralAccount: collateralAccountPublicKey,
-				authority: this.wallet.publicKey,
-				tokenProgram: TOKEN_PROGRAM_ID,
-				settlementState,
-			},
-		});
-	}
-
-	public async getTotalSettlementSize(): Promise<BN> {
-		const accountLoader = new BulkAccountLoader(
-			this.connection,
-			'processed',
-			50000
-		);
-		const clearingHouse = getClearingHouse(
-			getPollingClearingHouseConfig(
-				this.connection,
-				this.wallet,
-				this.program.programId,
-				accountLoader
-			)
-		);
-
-		console.log('loading all users');
-		const programUserAccounts =
-			(await this.program.account.user.all()) as any[];
-		const userArray: ClearingHouseUser[] = [];
-		for (const programUserAccount of programUserAccounts) {
-			const user = getClearingHouseUser(
-				getPollingClearingHouseUserConfig(
-					clearingHouse,
-					programUserAccount.account.authority,
-					accountLoader
-				)
-			);
-			userArray.push(user);
-		}
-
-		console.log('subscribing all users');
-		await bulkPollingUserSubscribe(userArray, accountLoader);
-
-		console.log('calculating settlement size');
-		const settlementSize = userArray.reduce((collateralToBeSettled, user) => {
-			return collateralToBeSettled.add(
-				user.getUserAccount().forgoPositionSettlement === 0
-					? user.getSettledPositionValue()
-					: ZERO
-			);
-		}, ZERO);
-
-		for (const user of userArray) {
-			await user.unsubscribe();
-		}
-
-		return settlementSize;
-	}
-
-	public async updateUserForgoSettlement(): Promise<TransactionSignature> {
-		return await this.program.rpc.updateUserForgoSettlement({
-			accounts: {
-				authority: this.wallet.publicKey,
-				user: await this.getUserAccountPublicKey(),
-			},
-		});
+		return oracleData;
 	}
 }