@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.33

package/src/clearingHouse.ts

@@ -50,9 +50,10 @@ import {
 	getClearingHouseSignerPublicKey,
 	getClearingHouseStateAccountPublicKey,
 	getInsuranceFundStakeAccountPublicKey,
-	getMarketPublicKey,
+	getPerpMarketPublicKey,
 	getSerumFulfillmentConfigPublicKey,
 	getSerumSignerPublicKey,
+	getSpotMarketPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
 	getUserStatsAccountPublicKey,
@@ -64,7 +65,7 @@ import {
 } from './accounts/types';
 import { TxSender } from './tx/types';
 import { wrapInTx } from './tx/utils';
-import { QUOTE_SPOT_MARKET_INDEX } from './constants/numericConstants';
+import { QUOTE_SPOT_MARKET_INDEX, ZERO } from './constants/numericConstants';
 import { findDirectionToClose, positionIsAvailable } from './math/position';
 import { getTokenAmount } from './math/spotBalance';
 import { DEFAULT_USER_NAME, encodeName } from './userName';
@@ -101,7 +102,7 @@ export class ClearingHouse {
 	opts?: ConfirmOptions;
 	users = new Map<number, ClearingHouseUser>();
 	userStats?: ClearingHouseUserStats;
-	activeUserId: number;
+	activeSubAccountId: number;
 	userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
 	accountSubscriber: ClearingHouseAccountSubscriber;
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -134,8 +135,8 @@ export class ClearingHouse {
 		);
 
 		this.authority = config.authority ?? this.wallet.publicKey;
-		const userIds = config.userIds ?? [0];
-		this.activeUserId = config.activeUserId ?? userIds[0];
+		const subAccountIds = config.subAccountIds ?? [0];
+		this.activeSubAccountId = config.activeSubAccountId ?? subAccountIds[0];
 		this.userAccountSubscriptionConfig =
 			config.accountSubscription?.type === 'polling'
 				? {
@@ -145,7 +146,7 @@ export class ClearingHouse {
 				: {
 						type: 'websocket',
 				  };
-		this.createUsers(userIds, this.userAccountSubscriptionConfig);
+		this.createUsers(subAccountIds, this.userAccountSubscriptionConfig);
 		if (config.userStats) {
 			this.userStats = new ClearingHouseUserStats({
 				clearingHouse: this,
@@ -201,23 +202,23 @@ export class ClearingHouse {
 	}
 
 	createUsers(
-		userIds: number[],
+		subAccountIds: number[],
 		accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig
 	): void {
-		for (const userId of userIds) {
-			const user = this.createUser(userId, accountSubscriptionConfig);
-			this.users.set(userId, user);
+		for (const subAccountId of subAccountIds) {
+			const user = this.createUser(subAccountId, accountSubscriptionConfig);
+			this.users.set(subAccountId, user);
 		}
 	}
 
 	createUser(
-		userId: number,
+		subAccountId: number,
 		accountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig
 	): ClearingHouseUser {
 		const userAccountPublicKey = getUserAccountPublicKeySync(
 			this.program.programId,
 			this.authority,
-			userId
+			subAccountId
 		);
 
 		return new ClearingHouseUser({
@@ -349,13 +350,13 @@ export class ClearingHouse {
 	/**
 	 * Update the wallet to use for clearing house transactions and linked user account
 	 * @param newWallet
-	 * @param userIds
-	 * @param activeUserId
+	 * @param subAccountIds
+	 * @param activeSubAccountId
 	 */
 	public async updateWallet(
 		newWallet: IWallet,
-		userIds = [0],
-		activeUserId = 0
+		subAccountIds = [0],
+		activeSubAccountId = 0
 	): Promise<void> {
 		const newProvider = new AnchorProvider(
 			this.connection,
@@ -380,39 +381,46 @@ export class ClearingHouse {
 			await Promise.all(this.unsubscribeUsers());
 		}
 		this.users.clear();
-		this.createUsers(userIds, this.userAccountSubscriptionConfig);
+		this.createUsers(subAccountIds, this.userAccountSubscriptionConfig);
 		if (this.isSubscribed) {
 			await Promise.all(this.subscribeUsers());
 		}
 
-		this.activeUserId = activeUserId;
+		this.activeSubAccountId = activeSubAccountId;
 		this.userStatsAccountPublicKey = undefined;
 	}
 
-	public async switchActiveUser(userId: number): Promise<void> {
-		this.activeUserId = userId;
+	public async switchActiveUser(subAccountId: number): Promise<void> {
+		this.activeSubAccountId = subAccountId;
 	}
 
-	public async addUser(userId: number): Promise<void> {
-		if (this.users.has(userId)) {
+	public async addUser(subAccountId: number): Promise<void> {
+		if (this.users.has(subAccountId)) {
 			return;
 		}
 
-		const user = this.createUser(userId, this.userAccountSubscriptionConfig);
+		const user = this.createUser(
+			subAccountId,
+			this.userAccountSubscriptionConfig
+		);
 		await user.subscribe();
-		this.users.set(userId, user);
+		this.users.set(subAccountId, user);
 	}
 
 	public async initializeUserAccount(
-		userId = 0,
+		subAccountId = 0,
 		name = DEFAULT_USER_NAME,
 		referrerInfo?: ReferrerInfo
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [userAccountPublicKey, initializeUserAccountIx] =
-			await this.getInitializeUserInstructions(userId, name, referrerInfo);
+			await this.getInitializeUserInstructions(
+				subAccountId,
+				name,
+				referrerInfo
+			);
 
 		const tx = new Transaction();
-		if (userId === 0) {
+		if (subAccountId === 0) {
 			// not the safest assumption, can explicitly check if user stats account exists if it causes problems
 			tx.add(await this.getInitializeUserStatsIx());
 		}
@@ -422,14 +430,14 @@ export class ClearingHouse {
 	}
 
 	async getInitializeUserInstructions(
-		userId = 0,
+		subAccountId = 0,
 		name = DEFAULT_USER_NAME,
 		referrerInfo?: ReferrerInfo
 	): Promise<[PublicKey, TransactionInstruction]> {
 		const userAccountPublicKey = await getUserAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
-			userId
+			subAccountId
 		);
 
 		const remainingAccounts = new Array<AccountMeta>();
@@ -463,7 +471,7 @@ export class ClearingHouse {
 
 		const nameBuffer = encodeName(name);
 		const initializeUserAccountIx =
-			await this.program.instruction.initializeUser(userId, nameBuffer, {
+			await this.program.instruction.initializeUser(subAccountId, nameBuffer, {
 				accounts: {
 					user: userAccountPublicKey,
 					userStats: this.getUserStatsAccountPublicKey(),
@@ -494,12 +502,18 @@ export class ClearingHouse {
 
 	public async updateUserName(
 		name: string,
-		userId = 0
+		subAccountId = 0
 	): Promise<TransactionSignature> {
+		const userAccountPublicKey = getUserAccountPublicKeySync(
+			this.program.programId,
+			this.wallet.publicKey,
+			subAccountId
+		);
+
 		const nameBuffer = encodeName(name);
-		return await this.program.rpc.updateUserName(userId, nameBuffer, {
+		return await this.program.rpc.updateUserName(subAccountId, nameBuffer, {
 			accounts: {
-				user: await this.getUserAccountPublicKey(),
+				user: userAccountPublicKey,
 				authority: this.wallet.publicKey,
 			},
 		});
@@ -507,10 +521,10 @@ export class ClearingHouse {
 
 	public async updateUserCustomMarginRatio(
 		marginRatio: number,
-		userId = 0
+		subAccountId = 0
 	): Promise<TransactionSignature> {
 		return await this.program.rpc.updateUserCustomMarginRatio(
-			userId,
+			subAccountId,
 			marginRatio,
 			{
 				accounts: {
@@ -523,9 +537,9 @@ export class ClearingHouse {
 
 	public async updateUserDelegate(
 		delegate: PublicKey,
-		userId = 0
+		subAccountId = 0
 	): Promise<TransactionSignature> {
-		return await this.program.rpc.updateUserDelegate(userId, delegate, {
+		return await this.program.rpc.updateUserDelegate(subAccountId, delegate, {
 			accounts: {
 				user: await this.getUserAccountPublicKey(),
 				authority: this.wallet.publicKey,
@@ -551,11 +565,11 @@ export class ClearingHouse {
 		);
 	}
 
-	public async deleteUser(userId = 0): Promise<TransactionSignature> {
+	public async deleteUser(subAccountId = 0): Promise<TransactionSignature> {
 		const userAccountPublicKey = getUserAccountPublicKeySync(
 			this.program.programId,
 			this.wallet.publicKey,
-			userId
+			subAccountId
 		);
 
 		const txSig = await this.program.rpc.deleteUser({
@@ -567,18 +581,18 @@ export class ClearingHouse {
 			},
 		});
 
-		await this.users.get(userId)?.unsubscribe();
-		this.users.delete(userId);
+		await this.users.get(subAccountId)?.unsubscribe();
+		this.users.delete(subAccountId);
 
 		return txSig;
 	}
 
-	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}`);
+	public getUser(subAccountId?: number): ClearingHouseUser {
+		subAccountId = subAccountId ?? this.activeSubAccountId;
+		if (!this.users.has(subAccountId)) {
+			throw new Error(`Clearing House has no user for user id ${subAccountId}`);
 		}
-		return this.users.get(userId);
+		return this.users.get(subAccountId);
 	}
 
 	public getUsers(): ClearingHouseUser[] {
@@ -606,14 +620,14 @@ export class ClearingHouse {
 		return this.getUser().userAccountPublicKey;
 	}
 
-	public getUserAccount(userId?: number): UserAccount | undefined {
-		return this.getUser(userId).getUserAccount();
+	public getUserAccount(subAccountId?: number): UserAccount | undefined {
+		return this.getUser(subAccountId).getUserAccount();
 	}
 
 	public getUserAccountAndSlot(
-		userId?: number
+		subAccountId?: number
 	): DataAndSlot<UserAccount> | undefined {
-		return this.getUser(userId).getUserAccountAndSlot();
+		return this.getUser(subAccountId).getUserAccountAndSlot();
 	}
 
 	public getSpotPosition(marketIndex: number): SpotPosition | undefined {
@@ -626,7 +640,20 @@ export class ClearingHouse {
 		const spotMarket = this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX);
 		const spotPosition = this.getSpotPosition(QUOTE_SPOT_MARKET_INDEX);
 		return getTokenAmount(
-			spotPosition.balance,
+			spotPosition.scaledBalance,
+			spotMarket,
+			spotPosition.balanceType
+		);
+	}
+
+	public getTokenAmount(marketIndex: number): BN {
+		const spotPosition = this.getSpotPosition(marketIndex);
+		if (spotPosition === undefined) {
+			return ZERO;
+		}
+		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		return getTokenAmount(
+			spotPosition.scaledBalance,
 			spotMarket,
 			spotPosition.balanceType
 		);
@@ -808,10 +835,17 @@ export class ClearingHouse {
 		amount: BN,
 		marketIndex: number,
 		collateralAccountPublicKey: PublicKey,
-		userId?: number,
+		subAccountId?: number,
 		reduceOnly = false
 	): Promise<TransactionSignature> {
 		const tx = new Transaction();
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: 600_000,
+				additionalFee: 0,
+			})
+		);
+
 		const additionalSigners: Array<Signer> = [];
 
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
@@ -840,7 +874,7 @@ export class ClearingHouse {
 			amount,
 			marketIndex,
 			collateralAccountPublicKey,
-			userId,
+			subAccountId,
 			reduceOnly,
 			true
 		);
@@ -872,15 +906,15 @@ export class ClearingHouse {
 		amount: BN,
 		marketIndex: number,
 		userTokenAccount: PublicKey,
-		userId?: number,
+		subAccountId?: number,
 		reduceOnly = false,
 		userInitialized = true
 	): Promise<TransactionInstruction> {
-		const userAccountPublicKey = userId
+		const userAccountPublicKey = subAccountId
 			? await getUserAccountPublicKey(
 					this.program.programId,
 					this.authority,
-					userId
+					subAccountId
 			  )
 			: await this.getUserAccountPublicKey();
 
@@ -1000,22 +1034,26 @@ export class ClearingHouse {
 	 * @param amount
 	 * @param userTokenAccount
 	 * @param marketIndex
-	 * @param userId
+	 * @param subAccountId
 	 * @param name
-	 * @param fromUserId
+	 * @param fromSubAccountId
 	 * @returns
 	 */
 	public async initializeUserAccountAndDepositCollateral(
 		amount: BN,
 		userTokenAccount: PublicKey,
 		marketIndex = 0,
-		userId = 0,
+		subAccountId = 0,
 		name = DEFAULT_USER_NAME,
-		fromUserId?: number,
+		fromSubAccountId?: number,
 		referrerInfo?: ReferrerInfo
 	): Promise<[TransactionSignature, PublicKey]> {
 		const [userAccountPublicKey, initializeUserAccountIx] =
-			await this.getInitializeUserInstructions(userId, name, referrerInfo);
+			await this.getInitializeUserInstructions(
+				subAccountId,
+				name,
+				referrerInfo
+			);
 
 		const additionalSigners: Array<Signer> = [];
 
@@ -1047,23 +1085,23 @@ export class ClearingHouse {
 		}
 
 		const depositCollateralIx =
-			fromUserId != null
+			fromSubAccountId != null
 				? await this.getTransferDepositIx(
 						amount,
 						marketIndex,
-						fromUserId,
-						userId
+						fromSubAccountId,
+						subAccountId
 				  )
 				: await this.getDepositInstruction(
 						amount,
 						marketIndex,
 						userTokenAccount,
-						userId,
+						subAccountId,
 						false,
 						false
 				  );
 
-		if (userId === 0) {
+		if (subAccountId === 0) {
 			tx.add(await this.getInitializeUserStatsIx());
 		}
 		tx.add(initializeUserAccountIx).add(depositCollateralIx);
@@ -1091,7 +1129,7 @@ export class ClearingHouse {
 	}
 
 	public async initializeUserAccountForDevnet(
-		userId = 0,
+		subAccountId = 0,
 		name = DEFAULT_USER_NAME,
 		marketIndex: number,
 		tokenFaucet: TokenFaucet,
@@ -1105,20 +1143,24 @@ export class ClearingHouse {
 			);
 
 		const [userAccountPublicKey, initializeUserAccountIx] =
-			await this.getInitializeUserInstructions(userId, name, referrerInfo);
+			await this.getInitializeUserInstructions(
+				subAccountId,
+				name,
+				referrerInfo
+			);
 
 		const depositCollateralIx = await this.getDepositInstruction(
 			amount,
 			marketIndex,
 			associateTokenPublicKey,
-			userId,
+			subAccountId,
 			false,
 			false
 		);
 
 		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToIx);
 
-		if (userId === 0) {
+		if (subAccountId === 0) {
 			tx.add(await this.getInitializeUserStatsIx());
 		}
 		tx.add(initializeUserAccountIx).add(depositCollateralIx);
@@ -1135,6 +1177,13 @@ export class ClearingHouse {
 		reduceOnly = false
 	): Promise<TransactionSignature> {
 		const tx = new Transaction();
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: 600_000,
+				additionalFee: 0,
+			})
+		);
+
 		const additionalSigners: Array<Signer> = [];
 
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
@@ -1241,16 +1290,16 @@ export class ClearingHouse {
 	public async transferDeposit(
 		amount: BN,
 		marketIndex: number,
-		fromUserId: number,
-		toUserId: number
+		fromSubAccountId: number,
+		toSubAccountId: number
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(
 				await this.getTransferDepositIx(
 					amount,
 					marketIndex,
-					fromUserId,
-					toUserId
+					fromSubAccountId,
+					toSubAccountId
 				)
 			),
 			[],
@@ -1262,24 +1311,24 @@ export class ClearingHouse {
 	public async getTransferDepositIx(
 		amount: BN,
 		marketIndex: number,
-		fromUserId: number,
-		toUserId: number
+		fromSubAccountId: number,
+		toSubAccountId: number
 	): Promise<TransactionInstruction> {
 		const fromUser = await getUserAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
-			fromUserId
+			fromSubAccountId
 		);
 		const toUser = await getUserAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
-			toUserId
+			toSubAccountId
 		);
 
 		let remainingAccounts;
-		if (this.users.has(fromUserId)) {
+		if (this.users.has(fromSubAccountId)) {
 			remainingAccounts = this.getRemainingAccounts({
-				userAccounts: [this.users.get(fromUserId).getUserAccount()],
+				userAccounts: [this.users.get(fromSubAccountId).getUserAccount()],
 				useMarketLastSlotCache: true,
 				writableSpotMarketIndexes: [marketIndex],
 			});
@@ -1287,7 +1336,7 @@ export class ClearingHouse {
 			const userAccountPublicKey = getUserAccountPublicKeySync(
 				this.program.programId,
 				this.authority,
-				fromUserId
+				fromSubAccountId
 			);
 
 			const fromUserAccount = (await this.program.account.user.fetch(
@@ -1331,6 +1380,7 @@ export class ClearingHouse {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				spotMarket: spotMarket.pubkey,
+				oracle: spotMarket.oracle,
 			},
 		});
 	}
@@ -1369,19 +1419,74 @@ export class ClearingHouse {
 		});
 	}
 
-	public async removeLiquidity(
+	public async removePerpLpShares(
+		marketIndex: number,
+		sharesToBurn?: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getRemovePerpLpSharesIx(marketIndex, sharesToBurn)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async removePerpLpSharesInExpiringMarket(
 		marketIndex: number,
+		userAccountPublicKey: PublicKey,
 		sharesToBurn?: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)),
+			wrapInTx(
+				await this.getRemovePerpLpSharesInExpiringMarket(
+					marketIndex,
+					userAccountPublicKey,
+					sharesToBurn
+				)
+			),
 			[],
 			this.opts
 		);
 		return txSig;
 	}
 
-	public async getRemoveLiquidityIx(
+	public async getRemovePerpLpSharesInExpiringMarket(
+		marketIndex: number,
+		userAccountPublicKey: PublicKey,
+		sharesToBurn?: BN
+	): Promise<TransactionInstruction> {
+		const userAccount = (await this.program.account.user.fetch(
+			userAccountPublicKey
+		)) as UserAccount;
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [userAccount],
+			useMarketLastSlotCache: true,
+			writablePerpMarketIndexes: [marketIndex],
+		});
+
+		if (sharesToBurn == undefined) {
+			const perpPosition = userAccount.perpPositions.filter(
+				(position) => position.marketIndex === marketIndex
+			)[0];
+			sharesToBurn = perpPosition.lpShares;
+			console.log('burning lp shares:', sharesToBurn.toString());
+		}
+
+		return this.program.instruction.removePerpLpSharesInExpiringMarket(
+			sharesToBurn,
+			marketIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
+	}
+
+	public async getRemovePerpLpSharesIx(
 		marketIndex: number,
 		sharesToBurn?: BN
 	): Promise<TransactionInstruction> {
@@ -1402,22 +1507,26 @@ export class ClearingHouse {
 			console.log('burning lp shares:', sharesToBurn.toString());
 		}
 
-		return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				user: userAccountPublicKey,
-				authority: this.wallet.publicKey,
-			},
-			remainingAccounts: remainingAccounts,
-		});
+		return this.program.instruction.removePerpLpShares(
+			sharesToBurn,
+			marketIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
 	}
 
-	public async addLiquidity(
+	public async addPerpLpShares(
 		amount: BN,
 		marketIndex: number
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.txSender.send(
-			wrapInTx(await this.getAddLiquidityIx(amount, marketIndex)),
+			wrapInTx(await this.getAddPerpLpSharesIx(amount, marketIndex)),
 			[],
 			this.opts
 		);
@@ -1425,7 +1534,7 @@ export class ClearingHouse {
 		return txSig;
 	}
 
-	public async getAddLiquidityIx(
+	public async getAddPerpLpSharesIx(
 		amount: BN,
 		marketIndex: number
 	): Promise<TransactionInstruction> {
@@ -1436,7 +1545,7 @@ export class ClearingHouse {
 			writablePerpMarketIndexes: [marketIndex],
 		});
 
-		return this.program.instruction.addLiquidity(amount, marketIndex, {
+		return this.program.instruction.addPerpLpShares(amount, marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
@@ -1652,6 +1761,34 @@ export class ClearingHouse {
 		});
 	}
 
+	public async settleExpiredMarketPoolsToRevenuePool(
+		perpMarketIndex: number
+	): Promise<TransactionSignature> {
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			perpMarketIndex
+		);
+
+		const spotMarketPublicKey = await getSpotMarketPublicKey(
+			this.program.programId,
+			QUOTE_SPOT_MARKET_INDEX
+		);
+
+		const ix =
+			await this.program.instruction.settleExpiredMarketPoolsToRevenuePool({
+				accounts: {
+					state: await this.getStatePublicKey(),
+					admin: this.wallet.publicKey,
+					spotMarket: spotMarketPublicKey,
+					perpMarket: perpMarketPublicKey,
+				},
+			});
+
+		const { txSig } = await this.txSender.send(wrapInTx(ix), [], this.opts);
+
+		return txSig;
+	}
+
 	public async cancelOrder(orderId?: number): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
 			wrapInTx(await this.getCancelOrderIx(orderId)),
@@ -1716,6 +1853,48 @@ export class ClearingHouse {
 		});
 	}
 
+	public async cancelOrders(
+		marketType?: MarketType,
+		marketIndex?: number,
+		direction?: PositionDirection
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getCancelOrdersIx(marketType, marketIndex, direction)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getCancelOrdersIx(
+		marketType: MarketType | null,
+		marketIndex: number | null,
+		direction: PositionDirection | null
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+		});
+
+		return await this.program.instruction.cancelOrders(
+			marketType ?? null,
+			marketIndex ?? null,
+			direction ?? null,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async fillOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
@@ -1931,90 +2110,11 @@ export class ClearingHouse {
 		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
 
 		if (fulfillmentConfig) {
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.pubkey,
-				isWritable: false,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumProgramId,
-				isWritable: false,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumMarket,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumRequestQueue,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumEventQueue,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumBids,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumAsks,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumBaseVault,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumQuoteVault,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: fulfillmentConfig.serumOpenOrders,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: getSerumSignerPublicKey(
-					fulfillmentConfig.serumProgramId,
-					fulfillmentConfig.serumMarket,
-					fulfillmentConfig.serumSignerNonce
-				),
-				isWritable: false,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: this.getSignerPublicKey(),
-				isWritable: false,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: TOKEN_PROGRAM_ID,
-				isWritable: false,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: this.getSpotMarketAccount(marketIndex).vault,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: this.getQuoteSpotMarketAccount().vault,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: this.getStateAccount().srmVault,
-				isWritable: false,
-				isSigner: false,
-			});
+			this.addSerumRemainingAccounts(
+				marketIndex,
+				remainingAccounts,
+				fulfillmentConfig
+			);
 		}
 
 		return await this.program.instruction.fillSpotOrder(
@@ -2035,6 +2135,97 @@ export class ClearingHouse {
 		);
 	}
 
+	addSerumRemainingAccounts(
+		marketIndex: number,
+		remainingAccounts: AccountMeta[],
+		fulfillmentConfig: SerumV3FulfillmentConfigAccount
+	) {
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.pubkey,
+			isWritable: false,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumProgramId,
+			isWritable: false,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumMarket,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumRequestQueue,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumEventQueue,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumBids,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumAsks,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumBaseVault,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumQuoteVault,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: fulfillmentConfig.serumOpenOrders,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: getSerumSignerPublicKey(
+				fulfillmentConfig.serumProgramId,
+				fulfillmentConfig.serumMarket,
+				fulfillmentConfig.serumSignerNonce
+			),
+			isWritable: false,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: this.getSignerPublicKey(),
+			isWritable: false,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: TOKEN_PROGRAM_ID,
+			isWritable: false,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: this.getSpotMarketAccount(marketIndex).vault,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: this.getQuoteSpotMarketAccount().vault,
+			isWritable: true,
+			isSigner: false,
+		});
+		remainingAccounts.push({
+			pubkey: this.getStateAccount().srmVault,
+			isWritable: false,
+			isSigner: false,
+		});
+	}
+
 	public async triggerOrder(
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
@@ -2226,6 +2417,171 @@ export class ClearingHouse {
 		);
 	}
 
+	public async placeAndTakeSpotOrder(
+		orderParams: OptionalOrderParams,
+		fulfillmentConfig?: SerumV3FulfillmentConfigAccount,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getPlaceAndTakeSpotOrderIx(
+					orderParams,
+					fulfillmentConfig,
+					makerInfo,
+					referrerInfo
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getPlaceAndTakeSpotOrderIx(
+		orderParams: OptionalOrderParams,
+		fulfillmentConfig?: SerumV3FulfillmentConfigAccount,
+		makerInfo?: MakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams, MarketType.SPOT);
+		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const userAccounts = [this.getUserAccount()];
+		if (makerInfo !== undefined) {
+			userAccounts.push(makerInfo.makerUserAccount);
+		}
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts,
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [
+				orderParams.marketIndex,
+				QUOTE_SPOT_MARKET_INDEX,
+			],
+		});
+
+		let makerOrderId = null;
+		if (makerInfo) {
+			makerOrderId = makerInfo.order.orderId;
+			remainingAccounts.push({
+				pubkey: makerInfo.maker,
+				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,
+			});
+		}
+
+		if (fulfillmentConfig) {
+			this.addSerumRemainingAccounts(
+				orderParams.marketIndex,
+				remainingAccounts,
+				fulfillmentConfig
+			);
+		}
+
+		return await this.program.instruction.placeAndTakeSpotOrder(
+			orderParams,
+			fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null,
+			makerOrderId,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async placeAndMakeSpotOrder(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getPlaceAndMakeSpotOrderIx(
+					orderParams,
+					takerInfo,
+					referrerInfo
+				)
+			),
+			[],
+			this.opts
+		);
+
+		return txSig;
+	}
+
+	public async getPlaceAndMakeSpotOrderIx(
+		orderParams: OptionalOrderParams,
+		takerInfo: TakerInfo,
+		referrerInfo?: ReferrerInfo
+	): Promise<TransactionInstruction> {
+		orderParams = this.getOrderParams(orderParams, MarketType.SPOT);
+		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(), takerInfo.takerUserAccount],
+			useMarketLastSlotCache: true,
+			writableSpotMarketIndexes: [
+				orderParams.marketIndex,
+				QUOTE_SPOT_MARKET_INDEX,
+			],
+		});
+
+		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.placeAndMakeSpotOrder(
+			orderParams,
+			takerOrderId,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
+					taker: takerInfo.taker,
+					takerStats: takerInfo.takerStats,
+					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
@@ -2321,46 +2677,6 @@ export class ClearingHouse {
 		});
 	}
 
-	public async settleExpiredPosition(
-		settleeUserAccountPublicKey: PublicKey,
-		settleeUserAccount: UserAccount,
-		marketIndex: number
-	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
-			wrapInTx(
-				await this.getSettleExpiredPositionIx(
-					settleeUserAccountPublicKey,
-					settleeUserAccount,
-					marketIndex
-				)
-			),
-			[],
-			this.opts
-		);
-		return txSig;
-	}
-
-	public async getSettleExpiredPositionIx(
-		settleeUserAccountPublicKey: PublicKey,
-		settleeUserAccount: UserAccount,
-		marketIndex: number
-	): Promise<TransactionInstruction> {
-		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [settleeUserAccount],
-			writablePerpMarketIndexes: [marketIndex],
-			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
-		});
-
-		return await this.program.instruction.settleExpiredPosition(marketIndex, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				authority: this.wallet.publicKey,
-				user: settleeUserAccountPublicKey,
-			},
-			remainingAccounts: remainingAccounts,
-		});
-	}
-
 	public async liquidatePerp(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
@@ -2660,7 +2976,7 @@ export class ClearingHouse {
 					liquidator: liquidatorPublicKey,
 					liquidatorStats: liquidatorStatsPublicKey,
 					spotMarketVault: spotMarket.vault,
-					insuranceFundVault: spotMarket.insuranceFundVault,
+					insuranceFundVault: spotMarket.insuranceFund.vault,
 					clearingHouseSigner: this.getSignerPublicKey(),
 					tokenProgram: TOKEN_PROGRAM_ID,
 				},
@@ -2717,7 +3033,7 @@ export class ClearingHouse {
 				liquidatorStats: liquidatorStatsPublicKey,
 				liquidator: liquidatorPublicKey,
 				spotMarketVault: spotMarket.vault,
-				insuranceFundVault: spotMarket.insuranceFundVault,
+				insuranceFundVault: spotMarket.insuranceFund.vault,
 				clearingHouseSigner: this.getSignerPublicKey(),
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
@@ -2726,11 +3042,11 @@ export class ClearingHouse {
 	}
 
 	public async updateFundingRate(
-		oracle: PublicKey,
-		marketIndex: number
+		perpMarketIndex: number,
+		oracle: PublicKey
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
-			wrapInTx(await this.getUpdateFundingRateIx(oracle, marketIndex)),
+			wrapInTx(await this.getUpdateFundingRateIx(perpMarketIndex, oracle)),
 			[],
 			this.opts
 		);
@@ -2738,13 +3054,17 @@ export class ClearingHouse {
 	}
 
 	public async getUpdateFundingRateIx(
-		oracle: PublicKey,
-		marketIndex: number
+		perpMarketIndex: number,
+		oracle: PublicKey
 	): Promise<TransactionInstruction> {
-		return await this.program.instruction.updateFundingRate(marketIndex, {
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			perpMarketIndex
+		);
+		return await this.program.instruction.updateFundingRate(perpMarketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
-				market: await getMarketPublicKey(this.program.programId, marketIndex),
+				perpMarket: perpMarketPublicKey,
 				oracle: oracle,
 			},
 		});
@@ -2793,7 +3113,7 @@ export class ClearingHouse {
 		this.eventEmitter.emit(eventName, data);
 	}
 
-	public getOracleDataForMarket(marketIndex: number): OraclePriceData {
+	public getOracleDataForPerpMarket(marketIndex: number): OraclePriceData {
 		const oracleKey = this.getPerpMarketAccount(marketIndex).amm.oracle;
 		const oracleData = this.getOraclePriceDataAndSlot(oracleKey).data;
 
@@ -2870,7 +3190,7 @@ export class ClearingHouse {
 				userStats: this.getUserStatsAccountPublicKey(),
 				authority: this.wallet.publicKey,
 				spotMarketVault: spotMarket.vault,
-				insuranceFundVault: spotMarket.insuranceFundVault,
+				insuranceFundVault: spotMarket.insuranceFund.vault,
 				clearingHouseSigner: this.getSignerPublicKey(),
 				userTokenAccount: collateralAccountPublicKey,
 				tokenProgram: TOKEN_PROGRAM_ID,
@@ -2906,7 +3226,7 @@ export class ClearingHouse {
 					insuranceFundStake: ifStakeAccountPublicKey,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.wallet.publicKey,
-					insuranceFundVault: spotMarketAccount.insuranceFundVault,
+					insuranceFundVault: spotMarketAccount.insuranceFund.vault,
 				},
 				remainingAccounts,
 			}
@@ -2938,7 +3258,7 @@ export class ClearingHouse {
 					insuranceFundStake: ifStakeAccountPublicKey,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.wallet.publicKey,
-					insuranceFundVault: spotMarketAccount.insuranceFundVault,
+					insuranceFundVault: spotMarketAccount.insuranceFund.vault,
 				},
 				remainingAccounts,
 			}
@@ -2969,7 +3289,7 @@ export class ClearingHouse {
 				insuranceFundStake: ifStakeAccountPublicKey,
 				userStats: this.getUserStatsAccountPublicKey(),
 				authority: this.wallet.publicKey,
-				insuranceFundVault: spotMarketAccount.insuranceFundVault,
+				insuranceFundVault: spotMarketAccount.insuranceFund.vault,
 				clearingHouseSigner: this.getSignerPublicKey(),
 				userTokenAccount: collateralAccountPublicKey,
 				tokenProgram: TOKEN_PROGRAM_ID,
@@ -2995,7 +3315,7 @@ export class ClearingHouse {
 				spotMarket: spotMarketAccount.pubkey,
 				spotMarketVault: spotMarketAccount.vault,
 				clearingHouseSigner: this.getSignerPublicKey(),
-				insuranceFundVault: spotMarketAccount.insuranceFundVault,
+				insuranceFundVault: spotMarketAccount.insuranceFund.vault,
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 			remainingAccounts,
@@ -3037,7 +3357,7 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					authority: this.wallet.publicKey,
 					spotMarketVault: spotMarket.vault,
-					insuranceFundVault: spotMarket.insuranceFundVault,
+					insuranceFundVault: spotMarket.insuranceFund.vault,
 					clearingHouseSigner: this.getSignerPublicKey(),
 					tokenProgram: TOKEN_PROGRAM_ID,
 				},