@velocity-exchange/sdk 0.0.5 → 0.2.0

package/src/velocityClient.ts

@@ -52,6 +52,7 @@ import {
 	PositionDirection,
 	ReferrerInfo,
 	ReferrerNameAccount,
+	RevenueShareEscrowAccount,
 	ScaleOrderParams,
 	SettlePnlMode,
 	SignedTxData,
@@ -115,7 +116,6 @@ import {
 	getUserAccountPublicKeySync,
 	getUserStatsAccountPublicKey,
 	getSignedMsgWsDelegatesAccountPublicKey,
-	getIfRebalanceConfigPublicKey,
 	getRevenueShareAccountPublicKey,
 	getRevenueShareEscrowAccountPublicKey,
 	getConstituentTargetBasePublicKey,
@@ -137,7 +137,6 @@ import {
 import { TxSender, TxSigAndSlot } from './tx/types';
 import {
 	BASE_PRECISION,
-	GOV_SPOT_MARKET_INDEX,
 	MARGIN_PRECISION,
 	MIN_I64,
 	ONE,
@@ -167,7 +166,7 @@ import {
 	VelocityProgram,
 	PYTH_LAZER_STORAGE_ACCOUNT_KEY,
 } from './config';
-import { Drift } from './idl/drift';
+import { Velocity } from './idl/velocity';
 import { WRAPPED_SOL_MINT } from './constants/spotMarkets';
 import { UserStats } from './userStats';
 import { isSpotPositionAvailable } from './math/spotPosition';
@@ -202,6 +201,8 @@ import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 import {
 	isBuilderOrderReferral,
 	isBuilderOrderCompleted,
+	escrowHasReferrer,
+	hasBuilderParams,
 } from './math/builder';
 import { TitanClient, SwapMode as TitanSwapMode } from './titan/titanClient';
 import { UnifiedSwapClient } from './swap/UnifiedSwapClient';
@@ -224,11 +225,12 @@ export class VelocityClient {
 	public program: VelocityProgram;
 	provider: AnchorProvider;
 	env: VelocityEnv;
-	opts?: ConfirmOptions;
+	opts: ConfirmOptions;
 	useHotWalletAdmin?: boolean;
 	users = new Map<string, User>();
 	userStats?: UserStats;
-	activeSubAccountId: number;
+	userStatsAccountPublicKey?: PublicKey;
+	activeSubAccountId: number | undefined;
 	userAccountSubscriptionConfig: UserSubscriptionConfig;
 	userStatsAccountSubscriptionConfig: UserStatsSubscriptionConfig;
 	accountSubscriber: VelocityClientAccountSubscriber;
@@ -245,13 +247,8 @@ export class VelocityClient {
 	mustIncludeSpotMarketIndexes = new Set<number>();
 	authority: PublicKey;
 
-	/** @deprecated use marketLookupTables */
-	marketLookupTable: PublicKey;
-	/** @deprecated use lookupTableAccounts */
-	lookupTableAccount: AddressLookupTableAccount;
-
 	marketLookupTables: PublicKey[];
-	lookupTableAccounts: AddressLookupTableAccount[];
+	lookupTableAccounts?: AddressLookupTableAccount[];
 
 	includeDelegates?: boolean;
 	authoritySubAccountMap?: Map<string, number[]>;
@@ -329,8 +326,8 @@ export class VelocityClient {
 			config.wallet,
 			this.opts
 		);
-		this.program = new Program<Drift>(
-			VelocityCore.defaultIdl() as unknown as Drift,
+		this.program = new Program<Velocity>(
+			VelocityCore.defaultIdl() as unknown as Velocity,
 			this.provider,
 			config.coder
 		);
@@ -438,19 +435,11 @@ export class VelocityClient {
 			});
 		}
 
-		this.marketLookupTable = config.marketLookupTable;
-		if (!this.marketLookupTable) {
-			this.marketLookupTable = new PublicKey(
-				configs[this.env].MARKET_LOOKUP_TABLE
-			);
-		}
-
-		this.marketLookupTables = config.marketLookupTables;
-		if (!this.marketLookupTables) {
-			this.marketLookupTables = configs[this.env].MARKET_LOOKUP_TABLES.map(
+		this.marketLookupTables =
+			config.marketLookupTables ??
+			configs[this.env].MARKET_LOOKUP_TABLES.map(
 				(tableAddr) => new PublicKey(tableAddr)
 			);
-		}
 
 		const delistedMarketSetting =
 			config.delistedMarketSetting || DelistedMarketSetting.Unsubscribe;
@@ -471,7 +460,6 @@ export class VelocityClient {
 		} else if (config.accountSubscription?.type === 'grpc') {
 			const accountSubscriberClass: any =
 				config.accountSubscription?.velocityClientAccountSubscriber ??
-				config.accountSubscription?.driftClientAccountSubscriber ??
 				grpcVelocityClientAccountSubscriber;
 			this.accountSubscriber = new accountSubscriberClass(
 				config.accountSubscription.grpcConfigs,
@@ -489,7 +477,6 @@ export class VelocityClient {
 		} else {
 			const accountSubscriberClass: any =
 				config.accountSubscription?.velocityClientAccountSubscriber ??
-				config.accountSubscription?.driftClientAccountSubscriber ??
 				WebSocketVelocityClientAccountSubscriber;
 			this.accountSubscriber = new accountSubscriberClass(
 				this.program as any,
@@ -632,6 +619,18 @@ export class VelocityClient {
 		return this.accountSubscriber.getMarketAccountAndSlot(marketIndex)?.data;
 	}
 
+	/**
+	 * Like {@link getPerpMarketAccount} but throws if the market is not loaded,
+	 * for call sites that require a guaranteed account.
+	 */
+	public getPerpMarketAccountOrThrow(marketIndex: number): PerpMarketAccount {
+		const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
+		if (!perpMarketAccount) {
+			throw new Error(`Perp market ${marketIndex} not found`);
+		}
+		return perpMarketAccount;
+	}
+
 	/**
 	 * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
 	 * @param marketIndex
@@ -661,7 +660,20 @@ export class VelocityClient {
 	public getSpotMarketAccount(
 		marketIndex: number
 	): SpotMarketAccount | undefined {
-		return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
+		return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex)
+			?.data;
+	}
+
+	/**
+	 * Like {@link getSpotMarketAccount} but throws if the market is not loaded,
+	 * for call sites that require a guaranteed account.
+	 */
+	public getSpotMarketAccountOrThrow(marketIndex: number): SpotMarketAccount {
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		if (!spotMarketAccount) {
+			throw new Error(`Spot market ${marketIndex} not found`);
+		}
+		return spotMarketAccount;
 	}
 
 	/**
@@ -672,7 +684,8 @@ export class VelocityClient {
 		marketIndex: number
 	): Promise<SpotMarketAccount | undefined> {
 		await this.accountSubscriber.fetch();
-		return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex).data;
+		return this.accountSubscriber.getSpotMarketAccountAndSlot(marketIndex)
+			?.data;
 	}
 
 	public getSpotMarketAccounts(): SpotMarketAccount[] {
@@ -683,9 +696,7 @@ export class VelocityClient {
 	}
 
 	public getQuoteSpotMarketAccount(): SpotMarketAccount {
-		return this.accountSubscriber.getSpotMarketAccountAndSlot(
-			QUOTE_SPOT_MARKET_INDEX
-		).data;
+		return this.getSpotMarketAccountOrThrow(QUOTE_SPOT_MARKET_INDEX);
 	}
 
 	public getOraclePriceDataAndSlot(
@@ -697,22 +708,6 @@ export class VelocityClient {
 		);
 	}
 
-	/** @deprecated use fetchAllLookupTableAccounts() */
-	public async fetchMarketLookupTableAccount(): Promise<AddressLookupTableAccount> {
-		if (this.lookupTableAccount) return this.lookupTableAccount;
-
-		if (!this.marketLookupTable) {
-			console.log('Market lookup table address not set');
-			return;
-		}
-
-		const lookupTableAccount = (
-			await this.connection.getAddressLookupTable(this.marketLookupTable)
-		).value;
-		this.lookupTableAccount = lookupTableAccount;
-
-		return lookupTableAccount;
-	}
 	public async fetchAllLookupTableAccounts(): Promise<
 		AddressLookupTableAccount[]
 	> {
@@ -751,7 +746,7 @@ export class VelocityClient {
 	}
 
 	/**
-	 * Update the wallet to use for drift transactions and linked user account
+	 * Update the wallet to use for velocity transactions and linked user account
 	 * @param newWallet
 	 * @param subAccountIds
 	 * @param activeSubAccountId
@@ -770,8 +765,8 @@ export class VelocityClient {
 			newWallet,
 			this.opts
 		);
-		const newProgram = new Program<Drift>(
-			VelocityCore.defaultIdl() as unknown as Drift,
+		const newProgram = new Program<Velocity>(
+			VelocityCore.defaultIdl() as unknown as Velocity,
 			newProvider
 		);
 
@@ -891,10 +886,11 @@ export class VelocityClient {
 
 		this.activeSubAccountId = subAccountId;
 		this.authority = authority ?? this.authority;
-		this.userStatsAccountPublicKey = getUserStatsAccountPublicKey(
+		const userStatsAccountPublicKey = getUserStatsAccountPublicKey(
 			this.program.programId,
 			this.authority
 		);
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
 
 		/* If changing the user authority ie switching from delegate to non-delegate account, need to re-subscribe to the user stats account */
 		if (authorityChanged && this.userStats) {
@@ -904,7 +900,7 @@ export class VelocityClient {
 
 			this.userStats = new UserStats({
 				velocityClient: this,
-				userStatsAccountPublicKey: this.userStatsAccountPublicKey,
+				userStatsAccountPublicKey: userStatsAccountPublicKey,
 				accountSubscription: this.userStatsAccountSubscriptionConfig,
 			});
 
@@ -920,7 +916,7 @@ export class VelocityClient {
 		authority = authority ?? this.authority;
 		const userKey = this.getUserMapKey(subAccountId, authority);
 
-		if (this.users.has(userKey) && this.users.get(userKey).isSubscribed) {
+		if (this.users.has(userKey) && this.users.get(userKey)?.isSubscribed) {
 			return true;
 		}
 
@@ -944,7 +940,7 @@ export class VelocityClient {
 	 * Adds and subscribes to users based on params set by the constructor or by updateWallet.
 	 */
 	public async addAndSubscribeToUsers(authority?: PublicKey): Promise<boolean> {
-		// save the rpc calls if driftclient is initialized without a real wallet
+		// save the rpc calls if velocityclient is initialized without a real wallet
 		if (this.skipLoadUsers) return true;
 
 		let result = true;
@@ -967,8 +963,8 @@ export class VelocityClient {
 				);
 			}
 		} else {
-			let userAccounts = [];
-			let delegatedAccounts = [];
+			let userAccounts: UserAccount[] = [];
+			let delegatedAccounts: UserAccount[] = [];
 
 			const userAccountsPromise = this.getUserAccountsForAuthority(
 				authority ?? this.wallet.publicKey
@@ -1569,7 +1565,7 @@ export class VelocityClient {
 
 	async getNextSubAccountId(): Promise<number> {
 		const userStats = this.getUserStats();
-		let userStatsAccount: UserStatsAccount;
+		let userStatsAccount: UserStatsAccount | undefined;
 		if (!userStats) {
 			userStatsAccount = await fetchUserStatsAccount(
 				this.connection,
@@ -1577,7 +1573,19 @@ export class VelocityClient {
 				this.wallet.publicKey
 			);
 		} else {
-			userStatsAccount = userStats.getAccount();
+			const account = userStats.getAccount();
+			if (!account) {
+				userStatsAccount = await fetchUserStatsAccount(
+					this.connection,
+					this.program,
+					this.wallet.publicKey
+				);
+			} else {
+				userStatsAccount = account;
+			}
+		}
+		if (!userStatsAccount) {
+			throw new Error('UserStats account does not exist');
 		}
 		return userStatsAccount.numberOfSubAccountsCreated;
 	}
@@ -1754,10 +1762,10 @@ export class VelocityClient {
 
 		await this.addUser(subAccountId, this.wallet.publicKey);
 
-		let remainingAccounts;
+		let remainingAccounts: AccountMeta[];
 		try {
 			remainingAccounts = this.getRemainingAccounts({
-				userAccounts: [this.getUserAccount(subAccountId)],
+				userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			});
 		} catch (err) {
 			remainingAccounts = [];
@@ -1838,6 +1846,32 @@ export class VelocityClient {
 		return txSig;
 	}
 
+	public async getUpdateUserAllowDelegateTransferIx(
+		allowDelegateTransfer: boolean
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.updateUserAllowDelegateTransfer(
+			allowDelegateTransfer,
+			{
+				accounts: {
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+				},
+			}
+		);
+	}
+
+	public async updateUserAllowDelegateTransfer(
+		allowDelegateTransfer: boolean
+	): Promise<TransactionSignature> {
+		const tx = await this.buildTransaction(
+			await this.getUpdateUserAllowDelegateTransferIx(allowDelegateTransfer),
+			this.txParams
+		);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
+
 	public async updateUserAdvancedLp(
 		updates: { advancedLp: boolean; subAccountId: number }[]
 	): Promise<TransactionSignature> {
@@ -1961,7 +1995,9 @@ export class VelocityClient {
 	public async getUserAccountsForDelegate(
 		delegate: PublicKey
 	): Promise<UserAccount[]> {
-		const programAccounts = await (this.program.account as any).user.all([
+		const programAccounts: ProgramAccount<UserAccount>[] = await (
+			this.program.account as any
+		).user.all([
 			{
 				memcmp: {
 					offset: 40,
@@ -1979,7 +2015,9 @@ export class VelocityClient {
 	public async getUserAccountsAndAddressesForAuthority(
 		authority: PublicKey
 	): Promise<ProgramAccount<UserAccount>[]> {
-		const programAccounts = await (this.program.account as any).user.all([
+		const programAccounts: ProgramAccount<UserAccount>[] = await (
+			this.program.account as any
+		).user.all([
 			{
 				memcmp: {
 					offset: 8,
@@ -1997,7 +2035,9 @@ export class VelocityClient {
 	public async getUserAccountsForAuthority(
 		authority: PublicKey
 	): Promise<UserAccount[]> {
-		const programAccounts = await (this.program.account as any).user.all([
+		const programAccounts: ProgramAccount<UserAccount>[] = await (
+			this.program.account as any
+		).user.all([
 			{
 				memcmp: {
 					offset: 8,
@@ -2015,7 +2055,9 @@ export class VelocityClient {
 	public async getReferredUserStatsAccountsByReferrer(
 		referrer: PublicKey
 	): Promise<UserStatsAccount[]> {
-		const programAccounts = await (this.program.account as any).userStats.all([
+		const programAccounts: ProgramAccount<UserStatsAccount>[] = await (
+			this.program.account as any
+		).userStats.all([
 			{
 				memcmp: {
 					offset: 40,
@@ -2033,7 +2075,7 @@ export class VelocityClient {
 	public async getReferrerNameAccountsForAuthority(
 		authority: PublicKey
 	): Promise<ReferrerNameAccount[]> {
-		const programAccounts = await (
+		const programAccounts: ProgramAccount<ReferrerNameAccount>[] = await (
 			this.program.account as any
 		).referrerName.all([
 			{
@@ -2137,7 +2179,9 @@ export class VelocityClient {
 			if (isSpotPositionAvailable(spotPosition)) {
 				continue;
 			}
-			const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
+			const spotMarket = this.getSpotMarketAccountOrThrow(
+				spotPosition.marketIndex
+			);
 			remainingAccounts.push({
 				isSigner: false,
 				isWritable: true,
@@ -2178,7 +2222,7 @@ export class VelocityClient {
 				userStats,
 				authority,
 				state: await this.getStatePublicKey(),
-				driftSigner: this.getSignerPublicKey(),
+				velocitySigner: this.getSignerPublicKey(),
 				keeper: this.wallet.publicKey,
 			},
 			remainingAccounts,
@@ -2273,17 +2317,26 @@ export class VelocityClient {
 	public getUser(subAccountId?: number, authority?: PublicKey): User {
 		subAccountId = subAccountId ?? this.activeSubAccountId;
 		authority = authority ?? this.authority;
+
+		if (subAccountId === undefined || authority === undefined) {
+			throw new Error('Subaccount ID and authority are required');
+		}
+
 		const userMapKey = this.getUserMapKey(subAccountId, authority);
 
-		if (!this.users.has(userMapKey)) {
+		const user = this.users.get(userMapKey);
+		if (!user) {
 			throw new Error(`VelocityClient has no user for user id ${userMapKey}`);
 		}
-		return this.users.get(userMapKey);
+		return user;
 	}
 
 	public hasUser(subAccountId?: number, authority?: PublicKey): boolean {
 		subAccountId = subAccountId ?? this.activeSubAccountId;
 		authority = authority ?? this.authority;
+		if (subAccountId === undefined || authority === undefined) {
+			throw new Error('Subaccount ID and authority are required');
+		}
 		const userMapKey = this.getUserMapKey(subAccountId, authority);
 
 		return this.users.has(userMapKey);
@@ -2292,18 +2345,29 @@ export class VelocityClient {
 	public getUsers(): User[] {
 		// delegate users get added to the end
 		return [...this.users.values()]
-			.filter((acct) =>
-				acct.getUserAccount().authority.equals(this.wallet.publicKey)
+			.filter(
+				(acct) => acct.getUserAccount()?.authority.equals(this.wallet.publicKey)
 			)
 			.concat(
 				[...this.users.values()].filter(
 					(acct) =>
-						!acct.getUserAccount().authority.equals(this.wallet.publicKey)
+						!acct.getUserAccount()?.authority.equals(this.wallet.publicKey)
 				)
 			);
 	}
 
-	public getUserStats(): UserStats {
+	public getUserStats(): UserStats | undefined {
+		return this.userStats;
+	}
+
+	/**
+	 * Like {@link getUserStats} but throws if there is no UserStats
+	 * subscription, for call sites that require a guaranteed account.
+	 */
+	public getUserStatsOrThrow(): UserStats {
+		if (!this.userStats) {
+			throw new Error('VelocityClient has no UserStats subscription');
+		}
 		return this.userStats;
 	}
 
@@ -2320,7 +2384,6 @@ export class VelocityClient {
 		)) as ReferrerNameAccount;
 	}
 
-	userStatsAccountPublicKey: PublicKey;
 	public getUserStatsAccountPublicKey(): PublicKey {
 		if (this.userStatsAccountPublicKey) {
 			return this.userStatsAccountPublicKey;
@@ -2347,6 +2410,18 @@ export class VelocityClient {
 		return this.getUser(subAccountId, authority).getUserAccount();
 	}
 
+	/**
+	 * Like {@link getUserAccount} but throws a named error instead of returning
+	 * `undefined` when the account has not been loaded yet. Use at call sites
+	 * that structurally require a loaded account.
+	 */
+	public getUserAccountOrThrow(
+		subAccountId?: number,
+		authority?: PublicKey
+	): UserAccount {
+		return this.getUser(subAccountId, authority).getUserAccountOrThrow();
+	}
+
 	/**
 	 * Forces a fetch to rpc before returning accounts. Useful for anchor tests.
 	 * @param subAccountId
@@ -2370,7 +2445,7 @@ export class VelocityClient {
 		marketIndex: number,
 		subAccountId?: number
 	): SpotPosition | undefined {
-		return this.getUserAccount(subAccountId).spotPositions.find(
+		return this.getUserAccountOrThrow(subAccountId).spotPositions.find(
 			(spotPosition) => spotPosition.marketIndex === marketIndex
 		);
 	}
@@ -2398,7 +2473,7 @@ export class VelocityClient {
 		if (spotPosition === undefined) {
 			return ZERO;
 		}
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		return getSignedTokenAmount(
 			getTokenAmount(
 				spotPosition.scaledBalance,
@@ -2415,7 +2490,7 @@ export class VelocityClient {
 	 * @param amount
 	 */
 	public convertToSpotPrecision(marketIndex: number, amount: BN | number): BN {
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		return castNumberToSpotPrecision(amount, spotMarket);
 	}
 
@@ -2444,7 +2519,7 @@ export class VelocityClient {
 	}
 
 	/**
-	 * Each drift instruction must include perp and sport market accounts in the ix remaining accounts.
+	 * Each velocity instruction must include perp and sport market accounts in the ix remaining accounts.
 	 * Use this function to force a subset of markets to be included in the remaining accounts for every ix
 	 *
 	 * @param perpMarketIndexes
@@ -2465,8 +2540,52 @@ export class VelocityClient {
 			this.mustIncludeSpotMarketIndexes.add(spotMarketIndex);
 		});
 	}
+	private cachePerpMarketSlot(
+		slot: number | undefined,
+		...marketIndexes: number[]
+	): void {
+		for (const marketIndex of marketIndexes) {
+			if (slot !== undefined) {
+				this.perpMarketLastSlotCache.set(marketIndex, slot);
+			} else {
+				this.perpMarketLastSlotCache.delete(marketIndex);
+			}
+		}
+	}
+
+	private cacheSpotMarketSlot(
+		slot: number | undefined,
+		...marketIndexes: number[]
+	): void {
+		for (const marketIndex of marketIndexes) {
+			if (slot !== undefined) {
+				this.spotMarketLastSlotCache.set(marketIndex, slot);
+			} else {
+				this.spotMarketLastSlotCache.delete(marketIndex);
+			}
+		}
+	}
+
 	getRemainingAccounts(params: RemainingAccountParams): AccountMeta[] {
-		return VelocityCore.remainingAccounts.getRemainingAccounts(this, params);
+		return VelocityCore.remainingAccounts.getRemainingAccounts(
+			{
+				getPerpMarketAccount: (marketIndex: number) =>
+					this.getPerpMarketAccountOrThrow(marketIndex),
+				getSpotMarketAccount: (marketIndex: number) =>
+					this.getSpotMarketAccountOrThrow(marketIndex),
+				getUserAccountAndSlot: (
+					subAccountId: number | undefined,
+					authority: PublicKey
+				) => this.getUserAccountAndSlot(subAccountId, authority),
+				activeSubAccountId: this.activeSubAccountId,
+				authority: this.authority,
+				perpMarketLastSlotCache: this.perpMarketLastSlotCache,
+				spotMarketLastSlotCache: this.spotMarketLastSlotCache,
+				mustIncludePerpMarketIndexes: this.mustIncludePerpMarketIndexes,
+				mustIncludeSpotMarketIndexes: this.mustIncludeSpotMarketIndexes,
+			},
+			params
+		);
 	}
 
 	addPerpMarketToRemainingAccountMaps(
@@ -2476,16 +2595,16 @@ export class VelocityClient {
 		spotMarketAccountMap: Map<number, AccountMeta>,
 		perpMarketAccountMap: Map<number, AccountMeta>
 	): void {
-		const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
+		const perpMarketAccount = this.getPerpMarketAccountOrThrow(marketIndex);
 		perpMarketAccountMap.set(marketIndex, {
 			pubkey: perpMarketAccount.pubkey,
 			isSigner: false,
 			isWritable: writable,
 		});
 		const oracleWritable =
-			writable && isVariant(perpMarketAccount.amm.oracleSource, 'prelaunch');
-		oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-			pubkey: perpMarketAccount.amm.oracle,
+			writable && isVariant(perpMarketAccount.oracleSource, 'prelaunch');
+		oracleAccountMap.set(perpMarketAccount.oracle.toString(), {
+			pubkey: perpMarketAccount.oracle,
 			isSigner: false,
 			isWritable: oracleWritable,
 		});
@@ -2503,7 +2622,7 @@ export class VelocityClient {
 		oracleAccountMap: Map<string, AccountMeta>,
 		spotMarketAccountMap: Map<number, AccountMeta>
 	): void {
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 		spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
 			pubkey: spotMarketAccount.pubkey,
 			isSigner: false,
@@ -2523,27 +2642,34 @@ export class VelocityClient {
 		remainingAccounts: AccountMeta[]
 	): void {
 		for (const builder of builders) {
-			// Add User account for the builder
+			// Add User account for the builder. Dedupe by pubkey: an authority may be
+			// both a builder and the referrer, in which case its User + RevenueShare
+			// accounts would otherwise be pushed twice. On-chain `load_revenue_share_map`
+			// rejects duplicates, which would silently abort the entire sweep.
 			const builderUserAccount = getUserAccountPublicKeySync(
 				this.program.programId,
 				builder,
 				0 // subAccountId 0 for builder user account
 			);
-			remainingAccounts.push({
-				pubkey: builderUserAccount,
-				isSigner: false,
-				isWritable: true,
-			});
+			if (!remainingAccounts.find((a) => a.pubkey.equals(builderUserAccount))) {
+				remainingAccounts.push({
+					pubkey: builderUserAccount,
+					isSigner: false,
+					isWritable: true,
+				});
+			}
 
 			const builderAccount = getRevenueShareAccountPublicKey(
 				this.program.programId,
 				builder
 			);
-			remainingAccounts.push({
-				pubkey: builderAccount,
-				isSigner: false,
-				isWritable: true,
-			});
+			if (!remainingAccounts.find((a) => a.pubkey.equals(builderAccount))) {
+				remainingAccounts.push({
+					pubkey: builderAccount,
+					isSigner: false,
+					isWritable: true,
+				});
+			}
 		}
 	}
 
@@ -2599,12 +2725,37 @@ export class VelocityClient {
 		};
 	}
 
-	public getOrder(orderId: number, subAccountId?: number): Order | undefined {
+	/**
+	 * Look up an open order by its program-assigned order ID from the cached user account.
+	 *
+	 * `orderId` is the monotonically incrementing u32 counter that the program assigns at
+	 * placement time — it is not known until the place instruction executes on-chain. Use
+	 * {@link getOrderByUserId} when you need to look up an order by the caller-supplied
+	 * `userOrderId` instead.
+	 *
+	 * Returns `undefined` when the order is not found (already filled, cancelled, or the
+	 * account cache is stale).
+	 */
+	public getOrder(
+		orderId: number | undefined,
+		subAccountId?: number
+	): Order | undefined {
 		return this.getUserAccount(subAccountId)?.orders.find(
 			(order) => order.orderId === orderId
 		);
 	}
 
+	/**
+	 * Look up an open order by the caller-supplied `userOrderId` from the cached user account.
+	 *
+	 * `userOrderId` is a 1-255 slot chosen by the caller in {@link OrderParams} and is stable
+	 * across the life of the order — useful when you need to reference an order before the
+	 * program-assigned {@link Order.orderId} is known (e.g. immediately after placing without
+	 * waiting for confirmation). Use {@link getOrder} when you have the program-assigned ID.
+	 *
+	 * Returns `undefined` when the order is not found (already filled, cancelled, or the
+	 * account cache is stale).
+	 */
 	public getOrderByUserId(
 		userOrderId: number,
 		subAccountId?: number
@@ -2627,7 +2778,7 @@ export class VelocityClient {
 		authority = this.wallet.publicKey,
 		allowOwnerOffCurve = false
 	): Promise<PublicKey> {
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		if (useNative && spotMarket.mint.equals(WRAPPED_SOL_MINT)) {
 			return authority;
 		}
@@ -2675,7 +2826,7 @@ export class VelocityClient {
 			authority?: PublicKey;
 		}
 	): Promise<TransactionInstruction[]> {
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 
 		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
 
@@ -2859,7 +3010,7 @@ export class VelocityClient {
 		);
 
 		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
-		this.spotMarketLastSlotCache.set(marketIndex, slot);
+		this.cacheSpotMarketSlot(slot, marketIndex);
 		return txSig;
 	}
 
@@ -2882,8 +3033,12 @@ export class VelocityClient {
 
 		let remainingAccounts = [];
 		if (userInitialized) {
+			const userAccount = await this.forceGetUserAccount(subAccountId);
+			if (!userAccount) {
+				throw new Error('User account not loaded after force fetch');
+			}
 			remainingAccounts = this.getRemainingAccounts({
-				userAccounts: [await this.forceGetUserAccount(subAccountId)],
+				userAccounts: [userAccount],
 				useMarketLastSlotCache: true,
 				writableSpotMarketIndexes: [marketIndex],
 			});
@@ -2894,7 +3049,7 @@ export class VelocityClient {
 			});
 		}
 
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 
 		this.addTokenMintToRemainingAccounts(spotMarketAccount, remainingAccounts);
 		if (this.isTransferHook(spotMarketAccount)) {
@@ -2957,7 +3112,11 @@ export class VelocityClient {
 			TOKEN_PROGRAM_ID
 		);
 
-		const result = {
+		const result: {
+			ixs: TransactionInstruction[];
+			signers: Signer[];
+			pubkey: PublicKey;
+		} = {
 			ixs: [],
 			signers: [],
 			pubkey: wrappedSolAccount,
@@ -3044,9 +3203,15 @@ export class VelocityClient {
 			mint,
 			hookAccount!.programId
 		);
-		const extraAccountMetas = getExtraAccountMetas(
-			await this.connection.getAccountInfo(extraAccountMetasAddress)!
+		const extraAccountMetasAccount = await this.connection.getAccountInfo(
+			extraAccountMetasAddress
 		);
+		if (!extraAccountMetasAccount) {
+			throw new Error(
+				'Extra account metas account not found for transfer hook'
+			);
+		}
+		const extraAccountMetas = getExtraAccountMetas(extraAccountMetasAccount);
 
 		for (const acc of extraAccountMetas) {
 			// assuming it's an extra account meta that does not rely on ix data
@@ -3132,7 +3297,7 @@ export class VelocityClient {
 			ixs.push(initializeSignedMsgUserOrdersAccountIx);
 		}
 
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 
 		const isSolMarket = spotMarket.mint.equals(WRAPPED_SOL_MINT);
 
@@ -3154,7 +3319,7 @@ export class VelocityClient {
 
 		const wSolAmount = isSolMarket ? amount.add(donateAmount) : donateAmount;
 
-		let wsolTokenAccount: PublicKey;
+		let wsolTokenAccount: PublicKey | undefined;
 		if (createWSOLTokenAccount) {
 			const { ixs: startIxs, pubkey } =
 				await this.getWrappedSolAccountCreationIxs(
@@ -3228,6 +3393,9 @@ export class VelocityClient {
 		ixs.push(depositCollateralIx);
 
 		if (!donateAmount.eq(ZERO)) {
+			if (!wsolTokenAccount) {
+				throw new Error('wsolTokenAccount is required to donate to rev pool');
+			}
 			const donateIx = await this.getDepositIntoSpotMarketRevenuePoolIx(
 				1,
 				donateAmount,
@@ -3249,6 +3417,9 @@ export class VelocityClient {
 		// Close the wrapped sol account at the end of the transaction
 		// Return funds to the deposit source (external wallet if provided)
 		if (createWSOLTokenAccount) {
+			if (!wsolTokenAccount) {
+				throw new Error('wsolTokenAccount was not created');
+			}
 			ixs.push(
 				createCloseAccountInstruction(
 					wsolTokenAccount,
@@ -3354,7 +3525,7 @@ export class VelocityClient {
 			additionalSigners,
 			this.opts
 		);
-		this.spotMarketLastSlotCache.set(marketIndex, slot);
+		this.cacheSpotMarketSlot(slot, marketIndex);
 
 		await this.addUser(subAccountId);
 
@@ -3423,7 +3594,7 @@ export class VelocityClient {
 	): Promise<TransactionInstruction[]> {
 		const withdrawIxs: TransactionInstruction[] = [];
 
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 
 		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
 
@@ -3518,7 +3689,7 @@ export class VelocityClient {
 			additionalSigners,
 			this.opts
 		);
-		this.spotMarketLastSlotCache.set(marketIndex, slot);
+		this.cacheSpotMarketSlot(slot, marketIndex);
 		return txSig;
 	}
 
@@ -3585,13 +3756,13 @@ export class VelocityClient {
 		const user = await this.getUserAccountPublicKey(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			useMarketLastSlotCache: true,
 			writableSpotMarketIndexes: [marketIndex],
 			readableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 
 		this.addTokenMintToRemainingAccounts(spotMarketAccount, remainingAccounts);
 		if (this.isTransferHook(spotMarketAccount)) {
@@ -3611,7 +3782,7 @@ export class VelocityClient {
 			state: await this.getStatePublicKey(),
 			spotMarket: spotMarketAccount.pubkey,
 			spotMarketVault: spotMarketAccount.vault,
-			driftSigner: this.getSignerPublicKey(),
+			velocitySigner: this.getSignerPublicKey(),
 			user,
 			userStats: this.getUserStatsAccountPublicKey(),
 			userTokenAccount,
@@ -3653,7 +3824,7 @@ export class VelocityClient {
 			fromSubAccountId === this.activeSubAccountId ||
 			toSubAccountId === this.activeSubAccountId
 		) {
-			this.spotMarketLastSlotCache.set(marketIndex, slot);
+			this.cacheSpotMarketSlot(slot, marketIndex);
 		}
 		return txSig;
 	}
@@ -3681,9 +3852,10 @@ export class VelocityClient {
 			fromSubAccountId,
 			this.wallet.publicKey
 		);
-		if (this.users.has(userMapKey)) {
+		const mapUser = this.users.get(userMapKey);
+		if (mapUser) {
 			remainingAccounts = this.getRemainingAccounts({
-				userAccounts: [this.users.get(userMapKey).getUserAccount()],
+				userAccounts: [mapUser.getUserAccountOrThrow()],
 				useMarketLastSlotCache: true,
 				writableSpotMarketIndexes: [marketIndex],
 			});
@@ -3711,12 +3883,96 @@ export class VelocityClient {
 				toUser,
 				userStats: this.getUserStatsAccountPublicKey(),
 				state: await this.getStatePublicKey(),
-				spotMarketVault: this.getSpotMarketAccount(marketIndex).vault,
+				spotMarketVault: this.getSpotMarketAccountOrThrow(marketIndex).vault,
 			},
 			remainingAccounts,
 		});
 	}
 
+	public async transferDepositByDelegate(
+		amount: BN,
+		marketIndex: number,
+		fromSubAccountId: number,
+		toSubAccountId: number,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getTransferDepositByDelegateIx(
+					amount,
+					marketIndex,
+					fromSubAccountId,
+					toSubAccountId
+				),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		if (
+			fromSubAccountId === this.activeSubAccountId ||
+			toSubAccountId === this.activeSubAccountId
+		) {
+			this.cacheSpotMarketSlot(slot, marketIndex);
+		}
+		return txSig;
+	}
+
+	public async getTransferDepositByDelegateIx(
+		amount: BN,
+		marketIndex: number,
+		fromSubAccountId: number,
+		toSubAccountId: number
+	): Promise<TransactionInstruction> {
+		const fromUser = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority,
+			fromSubAccountId
+		);
+		const toUser = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority,
+			toSubAccountId
+		);
+
+		let remainingAccounts;
+
+		const userMapKey = this.getUserMapKey(fromSubAccountId, this.authority);
+		const mapUser = this.users.get(userMapKey);
+		if (mapUser) {
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [mapUser.getUserAccountOrThrow()],
+				useMarketLastSlotCache: true,
+				writableSpotMarketIndexes: [marketIndex],
+			});
+		} else {
+			const fromUserAccount = (await (this.program.account as any).user.fetch(
+				fromUser
+			)) as UserAccount;
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [fromUserAccount],
+				useMarketLastSlotCache: true,
+				writableSpotMarketIndexes: [marketIndex],
+			});
+		}
+
+		return await this.program.instruction.transferDepositByDelegate(
+			marketIndex,
+			amount,
+			{
+				accounts: {
+					delegate: this.wallet.publicKey,
+					fromUser,
+					toUser,
+					userStats: this.getUserStatsAccountPublicKey(),
+					state: await this.getStatePublicKey(),
+					spotMarketVault: this.getSpotMarketAccountOrThrow(marketIndex).vault,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async transferPools(
 		depositFromMarketIndex: number,
 		depositToMarketIndex: number,
@@ -3750,10 +4006,13 @@ export class VelocityClient {
 			fromSubAccountId === this.activeSubAccountId ||
 			toSubAccountId === this.activeSubAccountId
 		) {
-			this.spotMarketLastSlotCache.set(depositFromMarketIndex, slot);
-			this.spotMarketLastSlotCache.set(depositToMarketIndex, slot);
-			this.spotMarketLastSlotCache.set(borrowFromMarketIndex, slot);
-			this.spotMarketLastSlotCache.set(borrowToMarketIndex, slot);
+			this.cacheSpotMarketSlot(
+				slot,
+				depositFromMarketIndex,
+				depositToMarketIndex,
+				borrowFromMarketIndex,
+				borrowToMarketIndex
+			);
 		}
 		return txSig;
 	}
@@ -3780,10 +4039,10 @@ export class VelocityClient {
 			toSubAccountId
 		);
 
-		const userAccounts = [this.getUserAccount(fromSubAccountId)];
+		const userAccounts = [this.getUserAccountOrThrow(fromSubAccountId)];
 
 		if (!isToNewSubAccount) {
-			userAccounts.push(this.getUserAccount(toSubAccountId));
+			userAccounts.push(this.getUserAccountOrThrow(toSubAccountId));
 		}
 
 		const remainingAccounts = this.getRemainingAccounts({
@@ -3798,10 +4057,10 @@ export class VelocityClient {
 		});
 
 		const tokenPrograms = new Set<string>();
-		const depositFromSpotMarket = this.getSpotMarketAccount(
+		const depositFromSpotMarket = this.getSpotMarketAccountOrThrow(
 			depositFromMarketIndex
 		);
-		const borrowFromSpotMarket = this.getSpotMarketAccount(
+		const borrowFromSpotMarket = this.getSpotMarketAccountOrThrow(
 			borrowFromMarketIndex
 		);
 
@@ -3834,17 +4093,17 @@ export class VelocityClient {
 					toUser,
 					userStats: this.getUserStatsAccountPublicKey(),
 					state: await this.getStatePublicKey(),
-					depositFromSpotMarketVault: this.getSpotMarketAccount(
+					depositFromSpotMarketVault: this.getSpotMarketAccountOrThrow(
 						depositFromMarketIndex
 					).vault,
 					depositToSpotMarketVault:
-						this.getSpotMarketAccount(depositToMarketIndex).vault,
-					borrowFromSpotMarketVault: this.getSpotMarketAccount(
+						this.getSpotMarketAccountOrThrow(depositToMarketIndex).vault,
+					borrowFromSpotMarketVault: this.getSpotMarketAccountOrThrow(
 						borrowFromMarketIndex
 					).vault,
 					borrowToSpotMarketVault:
-						this.getSpotMarketAccount(borrowToMarketIndex).vault,
-					driftSigner: this.getSignerPublicKey(),
+						this.getSpotMarketAccountOrThrow(borrowToMarketIndex).vault,
+					velocitySigner: this.getSignerPublicKey(),
 				},
 				remainingAccounts,
 			}
@@ -3893,8 +4152,8 @@ export class VelocityClient {
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [
-				this.getUserAccount(fromSubAccountId),
-				this.getUserAccount(toSubAccountId),
+				this.getUserAccountOrThrow(fromSubAccountId),
+				this.getUserAccountOrThrow(toSubAccountId),
 			],
 			useMarketLastSlotCache: true,
 			writablePerpMarketIndexes: [marketIndex],
@@ -3991,9 +4250,9 @@ export class VelocityClient {
 			subAccountId ?? this.activeSubAccountId
 		);
 
-		const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+		const perpMarketAccount = this.getPerpMarketAccountOrThrow(perpMarketIndex);
 		const spotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
-		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(spotMarketIndex);
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [],
@@ -4048,7 +4307,7 @@ export class VelocityClient {
 					this.authority,
 					subAccountId ?? this.activeSubAccountId
 				),
-				this.getUserAccount(subAccountId),
+				this.getUserAccountOrThrow(subAccountId),
 				[perpMarketIndex],
 				SettlePnlMode.TRY_SETTLE
 			);
@@ -4078,10 +4337,10 @@ export class VelocityClient {
 			subAccountId ?? this.activeSubAccountId
 		);
 
-		const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+		const perpMarketAccount = this.getPerpMarketAccountOrThrow(perpMarketIndex);
 		const spotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
-		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
-		const user = await this.getUserAccount(subAccountId);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(spotMarketIndex);
+		const user = await this.getUserAccountOrThrow(subAccountId);
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [user],
 			writableSpotMarketIndexes: [spotMarketIndex],
@@ -4141,18 +4400,26 @@ export class VelocityClient {
 			this.authority,
 			subAccountId ?? this.activeSubAccountId
 		);
-		const userAccount = this.getUserAccount(subAccountId);
+		const userAccount = this.getUserAccountOrThrow(subAccountId);
 
 		const tokenAmountDeposited =
 			this.getIsolatedPerpPositionTokenAmount(perpMarketIndex);
+		const isolatedPerpPosition = userAccount.perpPositions.find(
+			(p) => p.marketIndex === perpMarketIndex
+		);
+		if (!isolatedPerpPosition) {
+			throw new Error(
+				`No perp position found for market index ${perpMarketIndex}`
+			);
+		}
 		const isolatedPositionUnrealizedPnl = calculateClaimablePnl(
-			this.getPerpMarketAccount(perpMarketIndex),
-			this.getSpotMarketAccount(
-				this.getPerpMarketAccount(perpMarketIndex).quoteSpotMarketIndex
+			this.getPerpMarketAccountOrThrow(perpMarketIndex),
+			this.getSpotMarketAccountOrThrow(
+				this.getPerpMarketAccountOrThrow(perpMarketIndex).quoteSpotMarketIndex
 			),
-			userAccount.perpPositions.find((p) => p.marketIndex === perpMarketIndex),
+			isolatedPerpPosition,
 			this.getOracleDataForSpotMarket(
-				this.getPerpMarketAccount(perpMarketIndex).quoteSpotMarketIndex
+				this.getPerpMarketAccountOrThrow(perpMarketIndex).quoteSpotMarketIndex
 			)
 		);
 
@@ -4165,7 +4432,8 @@ export class VelocityClient {
 			: amount;
 		let associatedTokenAccount = userTokenAccount;
 		if (!associatedTokenAccount) {
-			const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+			const perpMarketAccount =
+				this.getPerpMarketAccountOrThrow(perpMarketIndex);
 			const quoteSpotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
 			associatedTokenAccount = await this.getAssociatedTokenAccount(
 				quoteSpotMarketIndex
@@ -4206,11 +4474,11 @@ export class VelocityClient {
 			this.authority,
 			subAccountId ?? this.activeSubAccountId
 		);
-		const perpMarketAccount = this.getPerpMarketAccount(perpMarketIndex);
+		const perpMarketAccount = this.getPerpMarketAccountOrThrow(perpMarketIndex);
 		const spotMarketIndex = perpMarketAccount.quoteSpotMarketIndex;
-		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(spotMarketIndex);
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			writableSpotMarketIndexes: [spotMarketIndex],
 			readablePerpMarketIndex: [perpMarketIndex],
 		});
@@ -4228,7 +4496,7 @@ export class VelocityClient {
 					authority: this.wallet.publicKey,
 					userTokenAccount: userTokenAccount,
 					tokenProgram: this.getTokenProgramForSpotMarket(spotMarketAccount),
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 				},
 				remainingAccounts,
 			}
@@ -4253,7 +4521,7 @@ export class VelocityClient {
 	public async updateSpotMarketCumulativeInterestIx(
 		marketIndex: number
 	): Promise<TransactionInstruction> {
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		return await this.program.instruction.updateSpotMarketCumulativeInterest({
 			accounts: {
 				state: await this.getStatePublicKey(),
@@ -4286,7 +4554,6 @@ export class VelocityClient {
 			undefined,
 			undefined,
 			undefined,
-			undefined,
 			subAccountId
 		);
 	}
@@ -4312,7 +4579,6 @@ export class VelocityClient {
 		makerInfo?: MakerInfo | MakerInfo[],
 		txParams?: TxParams,
 		bracketOrdersParams = new Array<OptionalOrderParams>(),
-		referrerInfo?: ReferrerInfo,
 		cancelExistingOrders?: boolean,
 		settlePnl?: boolean,
 		positionMaxLev?: number,
@@ -4334,7 +4600,7 @@ export class VelocityClient {
 
 		const ixPromisesForTxs: Record<
 			TxKeys,
-			Promise<TransactionInstruction | TransactionInstruction[]>
+			Promise<TransactionInstruction | TransactionInstruction[]> | undefined
 		> = {
 			cancelExistingOrdersTx: undefined,
 			settlePnlTx: undefined,
@@ -4393,14 +4659,18 @@ export class VelocityClient {
 					marketIndex,
 				},
 				makerInfo,
-				referrerInfo,
 				userAccount.subAccountId
 			);
 		}
 
 		const ixs = await Promise.all(Object.values(ixPromisesForTxs));
 
-		const ixsMap = ixs.reduce((acc, ix, i) => {
+		const ixsMap = ixs.reduce<
+			Record<
+				string,
+				TransactionInstruction | TransactionInstruction[] | undefined
+			>
+		>((acc, ix, i) => {
 			acc[txKeys[i]] = ix;
 			return acc;
 		}, {}) as MappedRecord<
@@ -4434,7 +4704,6 @@ export class VelocityClient {
 		makerInfo?: MakerInfo | MakerInfo[],
 		txParams?: TxParams,
 		bracketOrdersParams = new Array<OptionalOrderParams>(),
-		referrerInfo?: ReferrerInfo,
 		cancelExistingOrders?: boolean,
 		settlePnl?: boolean
 	): Promise<{
@@ -4450,7 +4719,6 @@ export class VelocityClient {
 			makerInfo,
 			txParams,
 			bracketOrdersParams,
-			referrerInfo,
 			cancelExistingOrders,
 			settlePnl
 		);
@@ -4466,7 +4734,7 @@ export class VelocityClient {
 			true
 		);
 
-		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+		this.cachePerpMarketSlot(slot, orderParams.marketIndex);
 
 		return {
 			txSig,
@@ -4510,10 +4778,69 @@ export class VelocityClient {
 			[],
 			this.opts
 		);
-		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+		this.cachePerpMarketSlot(slot, orderParams.marketIndex);
 		return txSig;
 	}
 
+	/**
+	 * Returns the RevenueShareEscrow account meta for the placing user when `orderParams`
+	 * carries a builder code (`builderIdx` + `builderFeeTenthBps`), otherwise `undefined`.
+	 * The on-chain handlers peek for this account last in `remaining_accounts`, so callers
+	 * must push it after the market/oracle/maker accounts.
+	 */
+	private getBuilderEscrowAccountMeta(
+		orderParams: Pick<OrderParams, 'builderIdx' | 'builderFeeTenthBps'>,
+		subAccountId?: number
+	): AccountMeta | undefined {
+		if (!hasBuilderParams(orderParams)) {
+			return undefined;
+		}
+		const authority =
+			this.getUserAccount(subAccountId)?.authority ?? this.authority;
+		return {
+			pubkey: getRevenueShareEscrowAccountPublicKey(
+				this.program.programId,
+				authority
+			),
+			isWritable: true,
+			isSigner: false,
+		};
+	}
+
+	/**
+	 * Returns the AccountMeta for the taker's RevenueShareEscrow when a fill of the
+	 * taker's order must include it: the order carries a builder code, or the taker
+	 * is referred (their escrow was initialized with a referrer). Returns `undefined`
+	 * when neither applies so no account meta is added to the transaction. The
+	 * on-chain handlers peek for this account last in `remaining_accounts`, so
+	 * callers must push it after the market/oracle/maker accounts.
+	 *
+	 * Throws when `takerEscrow` does not belong to `takerAuthority`.
+	 */
+	private getTakerEscrowAccountMeta(
+		takerAuthority: PublicKey,
+		orderHasBuilder: boolean,
+		takerEscrow?: RevenueShareEscrowAccount
+	): AccountMeta | undefined {
+		if (takerEscrow && !takerEscrow.authority.equals(takerAuthority)) {
+			throw new Error(
+				'takerEscrow.authority does not match the taker user account authority'
+			);
+		}
+		const takerIsReferred = takerEscrow && escrowHasReferrer(takerEscrow);
+		if (!orderHasBuilder && !takerIsReferred) {
+			return undefined;
+		}
+		return {
+			pubkey: getRevenueShareEscrowAccountPublicKey(
+				this.program.programId,
+				takerAuthority
+			),
+			isWritable: true,
+			isSigner: false,
+		};
+	}
+
 	public async getPlacePerpOrderIx(
 		orderParams: OptionalOrderParams,
 		subAccountId?: number,
@@ -4537,7 +4864,7 @@ export class VelocityClient {
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: depositToTradeArgs?.isMakingNewAccount
 				? []
-				: [this.getUserAccount(subAccountId)],
+				: [this.getUserAccountOrThrow(subAccountId)],
 			useMarketLastSlotCache: false,
 			readablePerpMarketIndex: orderParams.marketIndex,
 			readableSpotMarketIndexes: isDepositToTradeTx
@@ -4545,6 +4872,14 @@ export class VelocityClient {
 				: undefined,
 		});
 
+		const builderEscrow = this.getBuilderEscrowAccountMeta(
+			orderParams,
+			subAccountId
+		);
+		if (builderEscrow) {
+			remainingAccounts.push(builderEscrow);
+		}
+
 		return await VelocityCore.buildPlacePerpOrderInstruction({
 			program: this.program,
 			orderParams,
@@ -4577,14 +4912,14 @@ export class VelocityClient {
 		const marketAccountInfos = [];
 		const oracleAccountInfos = [];
 		for (const marketIndex of marketIndexes) {
-			const market = this.getPerpMarketAccount(marketIndex);
+			const market = this.getPerpMarketAccountOrThrow(marketIndex);
 			marketAccountInfos.push({
 				pubkey: market.pubkey,
 				isWritable: true,
 				isSigner: false,
 			});
 			oracleAccountInfos.push({
-				pubkey: market.amm.oracle,
+				pubkey: market.oracle,
 				isWritable: false,
 				isSigner: false,
 			});
@@ -4682,6 +5017,20 @@ export class VelocityClient {
 		);
 	}
 
+	/**
+	 * Cancel an open order and broadcast the transaction.
+	 *
+	 * When `orderId` is `undefined` (omitted or passed explicitly), the instruction is
+	 * sent with a `null` order ID and the program cancels the most recently placed order
+	 * on-chain via `get_last_order_id`. This is safe to use in a composed transaction
+	 * where a place instruction runs first and the assigned order ID is not yet known.
+	 *
+	 * Note: when `orderId` is `undefined` and `overrides.withdrawIsolatedDepositAmount`
+	 * is also provided, `getOrder` will return `undefined` (the ID is unknown client-side),
+	 * causing the withdraw path to throw — supply an explicit `orderId` in that case.
+	 *
+	 * @see {@link getCancelOrderIx} to obtain the instruction without sending.
+	 */
 	public async cancelOrder(
 		orderId?: number,
 		txParams?: TxParams,
@@ -4698,6 +5047,11 @@ export class VelocityClient {
 			const withdrawAmount = overrides.withdrawIsolatedDepositAmount;
 
 			if (withdrawAmount.gt(ZERO)) {
+				if (perpMarketIndex === undefined) {
+					throw new Error(
+						`Order ${orderId} not found when withdrawing isolated deposit`
+					);
+				}
 				const withdrawIxs =
 					await this.getWithdrawFromIsolatedPerpPositionIxsBundle(
 						withdrawAmount,
@@ -4716,6 +5070,21 @@ export class VelocityClient {
 		return txSig;
 	}
 
+	/**
+	 * Build a `cancelOrder` instruction for the given order.
+	 *
+	 * When `orderId` is `undefined` (omitted or passed explicitly), the instruction is
+	 * built with a `null` order ID (`orderId ?? null`). The program interprets a `null`
+	 * ID as "cancel the user's most recently placed order" (via `get_last_order_id`
+	 * on-chain). This is useful when composing a multi-instruction transaction where a
+	 * place instruction precedes the cancel and the program-assigned order ID is not yet
+	 * known at build time.
+	 *
+	 * When `orderId` is supplied, only that specific order is cancelled.
+	 *
+	 * @see {@link cancelOrder} to send the transaction directly.
+	 * @see {@link getCancelOrderByUserIdIx} to cancel by the caller-supplied `userOrderId`.
+	 */
 	public async getCancelOrderIx(
 		orderId?: number,
 		subAccountId?: number
@@ -4723,7 +5092,7 @@ export class VelocityClient {
 		const user = await this.getUserAccountPublicKey(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			useMarketLastSlotCache: true,
 		});
 
@@ -4759,11 +5128,14 @@ export class VelocityClient {
 	): Promise<TransactionInstruction> {
 		const user = await this.getUserAccountPublicKey(subAccountId);
 
-		const order = this.getOrderByUserId(userOrderId);
-		const oracle = this.getPerpMarketAccount(order.marketIndex).amm.oracle;
+		const order = this.getOrderByUserId(userOrderId, subAccountId);
+		if (!order) {
+			throw new Error(`Order with user order id ${userOrderId} not found`);
+		}
+		const oracle = this.getPerpMarketAccountOrThrow(order.marketIndex).oracle;
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			useMarketLastSlotCache: true,
 		});
 
@@ -4832,7 +5204,7 @@ export class VelocityClient {
 			user?.userAccountPublicKey ??
 			(await this.getUserAccountPublicKey(subAccountId));
 		const userAccount =
-			user?.getUserAccount() ?? this.getUserAccount(subAccountId);
+			user?.getUserAccount() ?? this.getUserAccountOrThrow(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [userAccount],
@@ -4875,9 +5247,9 @@ export class VelocityClient {
 	}
 
 	public async getCancelOrdersIx(
-		marketType: MarketType | null,
-		marketIndex: number | null,
-		direction: PositionDirection | null,
+		marketType: MarketType | null | undefined,
+		marketIndex: number | null | undefined,
+		direction: PositionDirection | null | undefined,
 		subAccountId?: number
 	): Promise<TransactionInstruction> {
 		const user = await this.getUserAccountPublicKey(subAccountId);
@@ -4894,7 +5266,7 @@ export class VelocityClient {
 		}
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			readablePerpMarketIndex,
 			readableSpotMarketIndexes,
 			useMarketLastSlotCache: true,
@@ -5025,7 +5397,7 @@ export class VelocityClient {
 		}
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			readablePerpMarketIndex,
 			readableSpotMarketIndexes,
 			useMarketLastSlotCache: true,
@@ -5034,6 +5406,19 @@ export class VelocityClient {
 		const formattedParams = params.map((item) => getOrderParams(item));
 		const authority = overrides?.authority ?? this.wallet.publicKey;
 
+		// The handler loads a single RevenueShareEscrow for the placing user, so push it once
+		// if any order in the batch carries a builder code.
+		const builderParam = formattedParams.find((p) => hasBuilderParams(p));
+		if (builderParam) {
+			const builderEscrow = this.getBuilderEscrowAccountMeta(
+				builderParam,
+				subAccountId
+			);
+			if (builderEscrow) {
+				remainingAccounts.push(builderEscrow);
+			}
+		}
+
 		return await VelocityCore.buildPlaceOrdersInstruction({
 			program: this.program,
 			formattedParams,
@@ -5066,7 +5451,7 @@ export class VelocityClient {
 		}
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			readablePerpMarketIndex,
 			readableSpotMarketIndexes,
 			useMarketLastSlotCache: true,
@@ -5151,7 +5536,7 @@ export class VelocityClient {
 		const isPerp = isVariant(params.marketType, 'perp');
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			readablePerpMarketIndex: isPerp ? [params.marketIndex] : [],
 			readableSpotMarketIndexes: isPerp ? [] : [params.marketIndex],
 			useMarketLastSlotCache: true,
@@ -5191,11 +5576,11 @@ export class VelocityClient {
 		user: UserAccount,
 		order?: Pick<Order, 'marketIndex' | 'orderId'>,
 		makerInfo?: MakerInfo | MakerInfo[],
-		referrerInfo?: ReferrerInfo,
 		txParams?: TxParams,
 		fillerSubAccountId?: number,
 		fillerAuthority?: PublicKey,
-		hasBuilderFee?: boolean
+		hasBuilderFee?: boolean,
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(
@@ -5204,11 +5589,11 @@ export class VelocityClient {
 					user,
 					order,
 					makerInfo,
-					referrerInfo,
 					fillerSubAccountId,
 					undefined,
 					fillerAuthority,
-					hasBuilderFee
+					hasBuilderFee,
+					takerEscrow
 				),
 				txParams
 			),
@@ -5221,13 +5606,17 @@ export class VelocityClient {
 	public async getFillPerpOrderIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
-		order: Pick<Order, 'marketIndex' | 'orderId'>,
+		order?: Pick<Order, 'marketIndex' | 'orderId'>,
 		makerInfo?: MakerInfo | MakerInfo[],
-		referrerInfo?: ReferrerInfo,
 		fillerSubAccountId?: number,
 		isSignedMsg?: boolean,
 		fillerAuthority?: PublicKey,
-		hasBuilderFee?: boolean
+		hasBuilderFee?: boolean,
+		// The program rejects fills that omit the taker's RevenueShareEscrow when the
+		// order has a builder OR the taker is referred with an escrow. The builder case
+		// is detected from the order bitflags; pass the taker's decoded escrow (e.g.
+		// from a RevenueShareEscrowMap) so referred takers also get it attached.
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionInstruction> {
 		const userStatsPublicKey = getUserStatsAccountPublicKey(
 			this.program.programId,
@@ -5261,7 +5650,10 @@ export class VelocityClient {
 			? order.marketIndex
 			: userAccount.orders.find(
 					(order) => order.orderId === userAccount.nextOrderId - 1
-			  ).marketIndex;
+			  )?.marketIndex;
+		if (marketIndex === undefined) {
+			throw new Error('No order found to fill');
+		}
 
 		makerInfo = Array.isArray(makerInfo)
 			? makerInfo
@@ -5291,24 +5683,6 @@ export class VelocityClient {
 			});
 		}
 
-		if (referrerInfo) {
-			const referrerIsMaker =
-				makerInfo.find((maker) => maker.maker.equals(referrerInfo.referrer)) !==
-				undefined;
-			if (!referrerIsMaker) {
-				remainingAccounts.push({
-					pubkey: referrerInfo.referrer,
-					isWritable: true,
-					isSigner: false,
-				});
-				remainingAccounts.push({
-					pubkey: referrerInfo.referrerStats,
-					isWritable: true,
-					isSigner: false,
-				});
-			}
-		}
-
 		let withBuilder = false;
 		if (hasBuilderFee) {
 			withBuilder = true;
@@ -5328,18 +5702,22 @@ export class VelocityClient {
 			}
 		}
 
-		if (withBuilder) {
-			remainingAccounts.push({
-				pubkey: getRevenueShareEscrowAccountPublicKey(
-					this.program.programId,
-					userAccount.authority
-				),
-				isWritable: true,
-				isSigner: false,
-			});
+		const takerEscrowMeta = this.getTakerEscrowAccountMeta(
+			userAccount.authority,
+			withBuilder,
+			takerEscrow
+		);
+		if (takerEscrowMeta) {
+			remainingAccounts.push(takerEscrowMeta);
 		}
 
-		const orderId = isSignedMsg ? null : order.orderId;
+		let orderId: number | null = null;
+		if (!isSignedMsg) {
+			if (!order) {
+				throw new Error('order is required to fill a non-signedMsg order');
+			}
+			orderId = order.orderId;
+		}
 		return await VelocityCore.buildFillPerpOrderInstruction({
 			program: this.program,
 			orderId,
@@ -5401,7 +5779,6 @@ export class VelocityClient {
 		_order?: Pick<Order, 'marketIndex' | 'orderId'>,
 		_fulfillmentConfig?: unknown,
 		_makerInfo?: MakerInfo | MakerInfo[],
-		_referrerInfo?: ReferrerInfo,
 		_txParams?: TxParams
 	): Promise<TransactionSignature> {
 		throw new Error(SPOT_DLOB_TRADING_DISABLED_MSG);
@@ -5413,14 +5790,13 @@ export class VelocityClient {
 		_order?: Pick<Order, 'marketIndex' | 'orderId'>,
 		_fulfillmentConfig?: unknown,
 		_makerInfo?: MakerInfo | MakerInfo[],
-		_referrerInfo?: ReferrerInfo,
 		_fillerPublicKey?: PublicKey
 	): Promise<TransactionInstruction> {
 		throw new Error(SPOT_DLOB_TRADING_DISABLED_MSG);
 	}
 
 	/**
-	 * Swap tokens in drift account using titan or jupiter
+	 * Swap tokens in velocity account using titan or jupiter
 	 * @param swapClient swap client to find routes and instructions (Titan or Jupiter)
 	 * @param jupiterClient @deprecated Use swapClient instead. Legacy parameter for backward compatibility
 	 * @param outMarketIndex the market index of the token you're buying
@@ -5431,7 +5807,7 @@ export class VelocityClient {
 	 * @param slippageBps the max slippage passed to the swap provider api
 	 * @param swapMode swap provider swapMode (ExactIn or ExactOut), default is ExactIn
 	 * @param route the swap provider route to use for the swap
-	 * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
+	 * @param reduceOnly specify if In or Out token on the velocity account must reduceOnly, checked at end of swap
 	 * @param v6 pass in the quote response from swap provider quote's API (deprecated, use quote instead)
 	 * @param quote pass in the quote response from swap provider quote's API
 	 * @param txParams
@@ -5543,8 +5919,7 @@ export class VelocityClient {
 		)) as VersionedTransaction;
 
 		const { txSig, slot } = await this.sendTransaction(tx);
-		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
-		this.spotMarketLastSlotCache.set(inMarketIndex, slot);
+		this.cacheSpotMarketSlot(slot, outMarketIndex, inMarketIndex);
 
 		return txSig;
 	}
@@ -5577,8 +5952,8 @@ export class VelocityClient {
 		ixs: TransactionInstruction[];
 		lookupTables: AddressLookupTableAccount[];
 	}> {
-		const outMarket = this.getSpotMarketAccount(outMarketIndex);
-		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+		const outMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
+		const inMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
 
 		const isExactOut = swapMode === 'ExactOut';
 		const exactOutBufferedAmountIn = amount.muln(1001).divn(1000); // Add 10bp buffer
@@ -5650,7 +6025,7 @@ export class VelocityClient {
 			slippageBps,
 			swapMode: isExactOut ? TitanSwapMode.ExactOut : TitanSwapMode.ExactIn,
 			onlyDirectRoutes,
-			sizeConstraint: MAX_TX_BYTE_SIZE - 375, // buffer for drift instructions
+			sizeConstraint: MAX_TX_BYTE_SIZE - 375, // buffer for velocity instructions
 		});
 
 		const titanInstructions = titanClient.getTitanInstructions({
@@ -5699,8 +6074,8 @@ export class VelocityClient {
 		ixs: TransactionInstruction[];
 		lookupTables: AddressLookupTableAccount[];
 	}> {
-		const outMarket = this.getSpotMarketAccount(outMarketIndex);
-		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+		const outMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
+		const inMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
 
 		if (!quote) {
 			const fetchedQuote = await jupiterClient.getQuote({
@@ -5810,7 +6185,7 @@ export class VelocityClient {
 	}
 
 	/**
-	 * Get the drift begin_swap and end_swap instructions
+	 * Get the velocity begin_swap and end_swap instructions
 	 *
 	 * @param outMarketIndex the market index of the token you're buying
 	 * @param inMarketIndex the market index of the token you're selling
@@ -5848,8 +6223,11 @@ export class VelocityClient {
 
 		const userAccounts = [];
 		try {
-			if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
-				userAccounts.push(this.getUser().getUserAccountAndSlot()!.data);
+			const userAccount = this.hasUser()
+				? this.getUser().getUserAccount()
+				: undefined;
+			if (userAccount) {
+				userAccounts.push(userAccount);
 			}
 		} catch (err) {
 			// ignore
@@ -5861,8 +6239,8 @@ export class VelocityClient {
 			readableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
-		const inSpotMarket = this.getSpotMarketAccount(inMarketIndex);
+		const outSpotMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
+		const inSpotMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
 
 		const outTokenProgram = this.getTokenProgramForSpotMarket(outSpotMarket);
 		const inTokenProgram = this.getTokenProgramForSpotMarket(inSpotMarket);
@@ -5915,7 +6293,7 @@ export class VelocityClient {
 					inTokenAccount,
 					outTokenAccount,
 					tokenProgram: inTokenProgram,
-					driftSigner: this.getStateAccount().signer,
+					velocitySigner: this.getStateAccount().signer,
 					instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
 				},
 				remainingAccounts,
@@ -5938,7 +6316,7 @@ export class VelocityClient {
 					inTokenAccount,
 					outTokenAccount,
 					tokenProgram: inTokenProgram,
-					driftSigner: this.getStateAccount().signer,
+					velocitySigner: this.getStateAccount().signer,
 					instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
 				},
 				remainingAccounts,
@@ -5983,8 +6361,8 @@ export class VelocityClient {
 		lookupTables: AddressLookupTableAccount[];
 	}> {
 		// Get market accounts to determine mints
-		const outMarket = this.getSpotMarketAccount(outMarketIndex);
-		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+		const outMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
+		const inMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
 
 		const isExactOut = swapMode === 'ExactOut';
 
@@ -6055,7 +6433,7 @@ export class VelocityClient {
 			amountInForBeginSwap = amount;
 		}
 
-		// Get drift swap instructions for begin and end
+		// Get velocity swap instructions for begin and end
 		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
 			outMarketIndex,
 			inMarketIndex,
@@ -6104,7 +6482,7 @@ export class VelocityClient {
 		amount: BN;
 		userAccountPublicKey?: PublicKey;
 	}): Promise<TransactionInstruction[]> {
-		const wSOLMint = this.getSpotMarketAccount(1).mint;
+		const wSOLMint = this.getSpotMarketAccountOrThrow(1).mint;
 		const mSOLAccount = await this.getAssociatedTokenAccount(2);
 		const wSOLAccount = await this.getAssociatedTokenAccount(1, false);
 
@@ -6411,34 +6789,34 @@ export class VelocityClient {
 	public async placeAndTakePerpOrder(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],
-		referrerInfo?: ReferrerInfo,
 		successCondition?: PlaceAndTakeOrderSuccessCondition,
 		auctionDurationPercentage?: number,
 		txParams?: TxParams,
-		subAccountId?: number
+		subAccountId?: number,
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.sendTransaction(
 			await this.buildTransaction(
 				await this.getPlaceAndTakePerpOrderIx(
 					orderParams,
 					makerInfo,
-					referrerInfo,
 					successCondition,
 					auctionDurationPercentage,
-					subAccountId
+					subAccountId,
+					undefined,
+					takerEscrow
 				),
 				txParams
 			),
 			[],
 			this.opts
 		);
-		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+		this.cachePerpMarketSlot(slot, orderParams.marketIndex);
 		return txSig;
 	}
 	public async preparePlaceAndTakePerpOrderWithAdditionalOrders(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],
-		referrerInfo?: ReferrerInfo,
 		bracketOrdersParams = new Array<OptionalOrderParams>(),
 		txParams?: TxParams,
 		subAccountId?: number,
@@ -6449,15 +6827,18 @@ export class VelocityClient {
 		optionalIxs?: TransactionInstruction[],
 		isolatedPositionDepositAmount?: BN
 	): Promise<{
-		placeAndTakeTx: Transaction | VersionedTransaction;
-		cancelExistingOrdersTx: Transaction | VersionedTransaction;
-		settlePnlTx: Transaction | VersionedTransaction;
-	}> {
+		placeAndTakeTx: Transaction | VersionedTransaction | undefined;
+		cancelExistingOrdersTx: Transaction | VersionedTransaction | undefined;
+		settlePnlTx: Transaction | VersionedTransaction | undefined;
+	} | null> {
 		const placeAndTakeIxs: TransactionInstruction[] = [];
 
 		type TxKeys = 'placeAndTakeTx' | 'cancelExistingOrdersTx' | 'settlePnlTx';
 
-		const txsToSign: Record<TxKeys, Transaction | VersionedTransaction> = {
+		const txsToSign: Record<
+			TxKeys,
+			Transaction | VersionedTransaction | undefined
+		> = {
 			placeAndTakeTx: undefined,
 			cancelExistingOrdersTx: undefined,
 			settlePnlTx: undefined,
@@ -6475,7 +6856,6 @@ export class VelocityClient {
 			const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(
 				orderParams,
 				makerInfo,
-				referrerInfo,
 				undefined,
 				auctionDurationPercentage,
 				subAccountId
@@ -6520,6 +6900,11 @@ export class VelocityClient {
 			};
 
 			if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
+				if (!txParams) {
+					throw new Error(
+						'txParams is required when simulating compute units or exiting early on failed simulation'
+					);
+				}
 				const placeAndTakeTxToSim = (await this.buildTransaction(
 					placeAndTakeIxs,
 					txParams,
@@ -6601,7 +6986,7 @@ export class VelocityClient {
 
 				const settlePnlIx = await this.settlePNLIx(
 					userAccountPublicKey,
-					this.getUserAccount(subAccountId),
+					this.getUserAccountOrThrow(subAccountId),
 					orderParams.marketIndex
 				);
 
@@ -6634,7 +7019,6 @@ export class VelocityClient {
 	public async placeAndTakePerpWithAdditionalOrders(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],
-		referrerInfo?: ReferrerInfo,
 		bracketOrdersParams = new Array<OptionalOrderParams>(),
 		txParams?: TxParams,
 		subAccountId?: number,
@@ -6645,12 +7029,11 @@ export class VelocityClient {
 		txSig: TransactionSignature;
 		signedCancelExistingOrdersTx?: Transaction;
 		signedSettlePnlTx?: Transaction;
-	}> {
+	} | null> {
 		const txsToSign =
 			await this.preparePlaceAndTakePerpOrderWithAdditionalOrders(
 				orderParams,
 				makerInfo,
-				referrerInfo,
 				bracketOrdersParams,
 				txParams,
 				subAccountId,
@@ -6671,6 +7054,10 @@ export class VelocityClient {
 			)
 		).signedTxMap;
 
+		if (!signedTxs.placeAndTakeTx) {
+			throw new Error('placeAndTakeTx was not built');
+		}
+
 		const { txSig, slot } = await this.sendTransaction(
 			signedTxs.placeAndTakeTx,
 			[],
@@ -6678,7 +7065,7 @@ export class VelocityClient {
 			true
 		);
 
-		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+		this.cachePerpMarketSlot(slot, orderParams.marketIndex);
 
 		return {
 			txSig,
@@ -6691,13 +7078,17 @@ export class VelocityClient {
 	public async getPlaceAndTakePerpOrderIx(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],
-		referrerInfo?: ReferrerInfo,
 		successCondition?: PlaceAndTakeOrderSuccessCondition,
 		auctionDurationPercentage?: number,
 		subAccountId?: number,
 		overrides?: {
 			authority?: PublicKey;
-		}
+		},
+		// place_and_take fills the placing user's (the taker's) order in-instruction, so
+		// their RevenueShareEscrow must be attached for BOTH builder fees and referrer
+		// revenue share. The builder case is detected from orderParams; pass the user's
+		// decoded escrow (e.g. from a RevenueShareEscrowMap) to cover the referred case.
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionInstruction> {
 		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
 		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
@@ -6709,7 +7100,7 @@ export class VelocityClient {
 			? [makerInfo]
 			: [];
 
-		const userAccounts = [this.getUserAccount(subAccountId)];
+		const userAccounts = [this.getUserAccountOrThrow(subAccountId)];
 		for (const maker of makerInfo) {
 			userAccounts.push(maker.makerUserAccount);
 		}
@@ -6733,22 +7124,13 @@ export class VelocityClient {
 			});
 		}
 
-		if (referrerInfo) {
-			const referrerIsMaker =
-				makerInfo.find((maker) => maker.maker.equals(referrerInfo.referrer)) !==
-				undefined;
-			if (!referrerIsMaker) {
-				remainingAccounts.push({
-					pubkey: referrerInfo.referrer,
-					isWritable: true,
-					isSigner: false,
-				});
-				remainingAccounts.push({
-					pubkey: referrerInfo.referrerStats,
-					isWritable: true,
-					isSigner: false,
-				});
-			}
+		const takerEscrowMeta = this.getTakerEscrowAccountMeta(
+			this.getUserAccount(subAccountId)?.authority ?? this.authority,
+			hasBuilderParams(orderParams),
+			takerEscrow
+		);
+		if (takerEscrowMeta) {
+			remainingAccounts.push(takerEscrowMeta);
 		}
 
 		let optionalParams = null;
@@ -6774,17 +7156,17 @@ export class VelocityClient {
 	public async placeAndMakePerpOrder(
 		orderParams: OptionalOrderParams,
 		takerInfo: TakerInfo,
-		referrerInfo?: ReferrerInfo,
 		txParams?: TxParams,
-		subAccountId?: number
+		subAccountId?: number,
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionSignature> {
 		const { txSig, slot } = await this.sendTransaction(
 			await this.buildTransaction(
 				await this.getPlaceAndMakePerpOrderIx(
 					orderParams,
 					takerInfo,
-					referrerInfo,
-					subAccountId
+					subAccountId,
+					takerEscrow
 				),
 				txParams
 			),
@@ -6792,7 +7174,7 @@ export class VelocityClient {
 			this.opts
 		);
 
-		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+		this.cachePerpMarketSlot(slot, orderParams.marketIndex);
 
 		return txSig;
 	}
@@ -6800,8 +7182,12 @@ export class VelocityClient {
 	public async getPlaceAndMakePerpOrderIx(
 		orderParams: OptionalOrderParams,
 		takerInfo: TakerInfo,
-		referrerInfo?: ReferrerInfo,
-		subAccountId?: number
+		subAccountId?: number,
+		// place_and_make fills the taker's order in-instruction, so the TAKER's
+		// RevenueShareEscrow must be attached when their order has a builder or they
+		// are referred with an escrow. The builder case is detected from the taker
+		// order bitflags; pass the taker's decoded escrow to cover the referred case.
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionInstruction> {
 		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
 		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
@@ -6809,36 +7195,21 @@ export class VelocityClient {
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [
-				this.getUserAccount(subAccountId),
+				this.getUserAccountOrThrow(subAccountId),
 				takerInfo.takerUserAccount,
 			],
 			useMarketLastSlotCache: true,
 			writablePerpMarketIndexes: [orderParams.marketIndex],
 		});
 
-		if (referrerInfo) {
-			remainingAccounts.push({
-				pubkey: referrerInfo.referrer,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: referrerInfo.referrerStats,
-				isWritable: true,
-				isSigner: false,
-			});
-		}
-
 		const takerOrderId = takerInfo.order.orderId;
-		if (hasBuilder(takerInfo.order)) {
-			remainingAccounts.push({
-				pubkey: getRevenueShareEscrowAccountPublicKey(
-					this.program.programId,
-					takerInfo.takerUserAccount.authority
-				),
-				isWritable: true,
-				isSigner: false,
-			});
+		const takerEscrowMeta = this.getTakerEscrowAccountMeta(
+			takerInfo.takerUserAccount.authority,
+			hasBuilder(takerInfo.order),
+			takerEscrow
+		);
+		if (takerEscrowMeta) {
+			remainingAccounts.push(takerEscrowMeta);
 		}
 		return await VelocityCore.buildPlaceAndMakePerpOrderInstruction({
 			program: this.program,
@@ -6874,7 +7245,7 @@ export class VelocityClient {
 	/**
 	 * Builds a deposit and place request for Swift service
 	 *
-	 * @param depositTx - The signed tx containing a drift deposit (e.g. see `buildSwiftDepositTx`)
+	 * @param depositTx - The signed tx containing a velocity deposit (e.g. see `buildSwiftDepositTx`)
 	 * @param orderParamsMessage - The order parameters message to sign
 	 * @param delegateSigner - Whether this is a delegate signer
 	 *
@@ -6940,8 +7311,11 @@ export class VelocityClient {
 
 	public signMessage(
 		message: Uint8Array,
-		keypair: Keypair = this.wallet.payer
+		keypair: Keypair | undefined = this.wallet.payer
 	): Buffer {
+		if (!keypair) {
+			throw new Error('No keypair available to sign message');
+		}
 		return Buffer.from(nacl.sign.detached(message, keypair.secretKey));
 	}
 
@@ -7012,10 +7386,7 @@ export class VelocityClient {
 			writableSpotMarketIndexes,
 		});
 
-		if (
-			signedMessage.builderFeeTenthBps !== null &&
-			signedMessage.builderIdx !== null
-		) {
+		if (hasBuilderParams(signedMessage)) {
 			remainingAccounts.push({
 				pubkey: getRevenueShareEscrowAccountPublicKey(
 					this.program.programId,
@@ -7078,21 +7449,21 @@ export class VelocityClient {
 			signingAuthority: PublicKey;
 		},
 		orderParams: OptionalOrderParams,
-		referrerInfo?: ReferrerInfo,
 		txParams?: TxParams,
 		subAccountId?: number,
 		precedingIxs: TransactionInstruction[] = [],
-		overrideCustomIxIndex?: number
+		overrideCustomIxIndex?: number,
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionSignature> {
 		const ixs = await this.getPlaceAndMakeSignedMsgPerpOrderIxs(
 			signedSignedMsgOrderParams,
 			signedMsgOrderUuid,
 			takerInfo,
 			orderParams,
-			referrerInfo,
 			subAccountId,
 			precedingIxs,
-			overrideCustomIxIndex
+			overrideCustomIxIndex,
+			takerEscrow
 		);
 		const { txSig, slot } = await this.sendTransaction(
 			await this.buildTransaction(ixs, txParams),
@@ -7100,7 +7471,7 @@ export class VelocityClient {
 			this.opts
 		);
 
-		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+		this.cachePerpMarketSlot(slot, orderParams.marketIndex);
 		return txSig;
 	}
 
@@ -7114,10 +7485,13 @@ export class VelocityClient {
 			signingAuthority: PublicKey;
 		},
 		orderParams: OptionalOrderParams,
-		referrerInfo?: ReferrerInfo,
 		subAccountId?: number,
 		precedingIxs: TransactionInstruction[] = [],
-		overrideCustomIxIndex?: number
+		overrideCustomIxIndex?: number,
+		// fills the taker's order in-instruction; pass the taker's decoded escrow so a
+		// referred taker's escrow is attached even when the signed order carries no
+		// builder fee
+		takerEscrow?: RevenueShareEscrowAccount
 	): Promise<TransactionInstruction[]> {
 		const [signedMsgOrderSignatureIx, placeTakerSignedMsgPerpOrderIx] =
 			await this.getPlaceSignedMsgTakerPerpOrderIxs(
@@ -7134,26 +7508,13 @@ export class VelocityClient {
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [
-				this.getUserAccount(subAccountId),
+				this.getUserAccountOrThrow(subAccountId),
 				takerInfo.takerUserAccount,
 			],
 			useMarketLastSlotCache: false,
 			writablePerpMarketIndexes: [orderParams.marketIndex],
 		});
 
-		if (referrerInfo) {
-			remainingAccounts.push({
-				pubkey: referrerInfo.referrer,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: referrerInfo.referrerStats,
-				isWritable: true,
-				isSigner: false,
-			});
-		}
-
 		const isDelegateSigner = takerInfo.signingAuthority.equals(
 			takerInfo.takerUserAccount.delegate
 		);
@@ -7166,18 +7527,13 @@ export class VelocityClient {
 			borshBuf,
 			isDelegateSigner
 		);
-		if (
-			signedMessage.builderFeeTenthBps !== null &&
-			signedMessage.builderIdx !== null
-		) {
-			remainingAccounts.push({
-				pubkey: getRevenueShareEscrowAccountPublicKey(
-					this.program.programId,
-					takerInfo.takerUserAccount.authority
-				),
-				isWritable: true,
-				isSigner: false,
-			});
+		const takerEscrowMeta = this.getTakerEscrowAccountMeta(
+			takerInfo.takerUserAccount.authority,
+			hasBuilderParams(signedMessage),
+			takerEscrow
+		);
+		if (takerEscrowMeta) {
+			remainingAccounts.push(takerEscrowMeta);
 		}
 
 		const placeAndMakeIx =
@@ -7212,7 +7568,6 @@ export class VelocityClient {
 		_orderParams: OptionalOrderParams,
 		_fulfillmentConfig?: unknown,
 		_makerInfo?: MakerInfo,
-		_referrerInfo?: ReferrerInfo,
 		_txParams?: TxParams,
 		_subAccountId?: number
 	) {
@@ -7223,7 +7578,6 @@ export class VelocityClient {
 		_orderParams: OptionalOrderParams,
 		_fulfillmentConfig?: unknown,
 		_makerInfo?: MakerInfo,
-		_referrerInfo?: ReferrerInfo,
 		_txParams?: TxParams,
 		_subAccountId?: number
 	): Promise<TransactionSignature> {
@@ -7233,7 +7587,6 @@ export class VelocityClient {
 		_orderParams: OptionalOrderParams,
 		_fulfillmentConfig?: unknown,
 		_makerInfo?: MakerInfo,
-		_referrerInfo?: ReferrerInfo,
 		_subAccountId?: number
 	): Promise<TransactionInstruction> {
 		throw new Error(SPOT_DLOB_TRADING_DISABLED_MSG);
@@ -7243,7 +7596,6 @@ export class VelocityClient {
 		_orderParams: OptionalOrderParams,
 		_takerInfo: TakerInfo,
 		_fulfillmentConfig?: unknown,
-		_referrerInfo?: ReferrerInfo,
 		_txParams?: TxParams,
 		_subAccountId?: number
 	): Promise<TransactionSignature> {
@@ -7254,7 +7606,6 @@ export class VelocityClient {
 		_orderParams: OptionalOrderParams,
 		_takerInfo: TakerInfo,
 		_fulfillmentConfig?: unknown,
-		_referrerInfo?: ReferrerInfo,
 		_subAccountId?: number
 	): Promise<TransactionInstruction> {
 		throw new Error(SPOT_DLOB_TRADING_DISABLED_MSG);
@@ -7287,7 +7638,6 @@ export class VelocityClient {
 			undefined,
 			undefined,
 			undefined,
-			undefined,
 			subAccountId
 		);
 	}
@@ -7437,8 +7787,12 @@ export class VelocityClient {
 		const userPubKey =
 			overrides?.user?.getUserAccountPublicKey() ??
 			(await this.getUserAccountPublicKey(subAccountId));
+		const overrideUserAccount = overrides?.user?.getUserAccount();
+		if (overrides?.user && !overrideUserAccount) {
+			throw new Error('modifyOrder: override user account is not loaded');
+		}
 		const userAccount =
-			overrides?.user?.getUserAccount() ?? this.getUserAccount(subAccountId);
+			overrideUserAccount ?? this.getUserAccountOrThrow(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [userAccount],
@@ -7464,7 +7818,7 @@ export class VelocityClient {
 
 		const authority =
 			overrides?.authority ??
-			overrides?.user?.getUserAccount().authority ??
+			overrideUserAccount?.authority ??
 			this.wallet.publicKey;
 		return await VelocityCore.buildModifyOrderInstruction({
 			program: this.program,
@@ -7567,7 +7921,7 @@ export class VelocityClient {
 		const user = await this.getUserAccountPublicKey(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [this.getUserAccountOrThrow(subAccountId)],
 			useMarketLastSlotCache: true,
 		});
 
@@ -7620,7 +7974,7 @@ export class VelocityClient {
 
 		if (filterInvalidMarkets) {
 			for (const marketIndex of marketIndexes) {
-				const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
+				const perpMarketAccount = this.getPerpMarketAccountOrThrow(marketIndex);
 				const oraclePriceData = this.getOracleDataForPerpMarket(marketIndex);
 				const stateAccountAndSlot =
 					this.accountSubscriber.getStateAccountAndSlot();
@@ -7775,7 +8129,7 @@ export class VelocityClient {
 							isWritable: true,
 						});
 					}
-					if (!escrow.referrer.equals(PublicKey.default)) {
+					if (escrowHasReferrer(escrow)) {
 						this.addBuilderToRemainingAccounts(
 							[escrow.referrer],
 							remainingAccounts
@@ -7978,7 +8332,7 @@ export class VelocityClient {
 					}
 
 					// Add referrer's User and RevenueShare accounts
-					if (!escrow.referrer.equals(PublicKey.default)) {
+					if (escrowHasReferrer(escrow)) {
 						this.addBuilderToRemainingAccounts(
 							[escrow.referrer],
 							remainingAccounts
@@ -8080,7 +8434,7 @@ export class VelocityClient {
 			[],
 			this.opts
 		);
-		this.perpMarketLastSlotCache.set(marketIndex, slot);
+		this.cachePerpMarketSlot(slot, marketIndex);
 		return txSig;
 	}
 	public async getLiquidatePerpIx(
@@ -8102,7 +8456,10 @@ export class VelocityClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				this.getUserAccountOrThrow(liquidatorSubAccountId),
+				userAccount,
+			],
 			useMarketLastSlotCache: true,
 			writablePerpMarketIndexes: [marketIndex],
 		});
@@ -8144,7 +8501,7 @@ export class VelocityClient {
 			[],
 			this.opts
 		);
-		this.perpMarketLastSlotCache.set(marketIndex, slot);
+		this.cachePerpMarketSlot(slot, marketIndex);
 		return txSig;
 	}
 
@@ -8225,8 +8582,7 @@ export class VelocityClient {
 			[],
 			this.opts
 		);
-		this.spotMarketLastSlotCache.set(assetMarketIndex, slot);
-		this.spotMarketLastSlotCache.set(liabilityMarketIndex, slot);
+		this.cacheSpotMarketSlot(slot, assetMarketIndex, liabilityMarketIndex);
 		return txSig;
 	}
 
@@ -8250,7 +8606,10 @@ export class VelocityClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				this.getUserAccountOrThrow(liquidatorSubAccountId),
+				userAccount,
+			],
 			useMarketLastSlotCache: true,
 			writableSpotMarketIndexes: [liabilityMarketIndex, assetMarketIndex],
 		});
@@ -8287,7 +8646,6 @@ export class VelocityClient {
 		quote,
 		userAccount,
 		userAccountPublicKey,
-		userStatsAccountPublicKey,
 		liquidatorSubAccountId,
 		maxAccounts,
 	}: {
@@ -8303,15 +8661,15 @@ export class VelocityClient {
 		quote?: QuoteResponse;
 		userAccount: UserAccount;
 		userAccountPublicKey: PublicKey;
-		userStatsAccountPublicKey: PublicKey;
 		liquidatorSubAccountId?: number;
 		maxAccounts?: number;
 	}): Promise<{
 		ixs: TransactionInstruction[];
 		lookupTables: AddressLookupTableAccount[];
 	}> {
-		const liabilityMarket = this.getSpotMarketAccount(liabilityMarketIndex);
-		const assetMarket = this.getSpotMarketAccount(assetMarketIndex);
+		const liabilityMarket =
+			this.getSpotMarketAccountOrThrow(liabilityMarketIndex);
+		const assetMarket = this.getSpotMarketAccountOrThrow(assetMarketIndex);
 
 		if (!quote) {
 			const fetchedQuote = await jupiterClient.getQuote({
@@ -8397,7 +8755,6 @@ export class VelocityClient {
 			liabilityTokenAccount,
 			userAccount,
 			userAccountPublicKey,
-			userStatsAccountPublicKey,
 			liquidatorSubAccountId,
 		});
 
@@ -8412,7 +8769,7 @@ export class VelocityClient {
 	}
 
 	/**
-	 * Get the drift liquidate_spot_with_swap instructions
+	 * Get the velocity liquidate_spot_with_swap instructions
 	 *
 	 * @param liabilityMarketIndex the market index of the token you're buying
 	 * @param assetMarketIndex the market index of the token you're selling
@@ -8421,7 +8778,6 @@ export class VelocityClient {
 	 * @param liabilityTokenAccount the token account to receive the tokens being bought
 	 * @param userAccount
 	 * @param userAccountPublicKey
-	 * @param userStatsAccountPublicKey
 	 */
 	public async getLiquidateSpotWithSwapIx({
 		liabilityMarketIndex,
@@ -8431,7 +8787,6 @@ export class VelocityClient {
 		liabilityTokenAccount,
 		userAccount,
 		userAccountPublicKey,
-		userStatsAccountPublicKey,
 		liquidatorSubAccountId,
 	}: {
 		liabilityMarketIndex: number;
@@ -8441,7 +8796,6 @@ export class VelocityClient {
 		liabilityTokenAccount: PublicKey;
 		userAccount: UserAccount;
 		userAccountPublicKey: PublicKey;
-		userStatsAccountPublicKey: PublicKey;
 		liquidatorSubAccountId?: number;
 	}): Promise<{
 		beginSwapIx: TransactionInstruction;
@@ -8450,7 +8804,6 @@ export class VelocityClient {
 		const liquidatorAccountPublicKey = await this.getUserAccountPublicKey(
 			liquidatorSubAccountId
 		);
-		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const userAccounts = [userAccount];
 		const remainingAccounts = this.getRemainingAccounts({
@@ -8459,8 +8812,9 @@ export class VelocityClient {
 			readableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		const liabilitySpotMarket = this.getSpotMarketAccount(liabilityMarketIndex);
-		const assetSpotMarket = this.getSpotMarketAccount(assetMarketIndex);
+		const liabilitySpotMarket =
+			this.getSpotMarketAccountOrThrow(liabilityMarketIndex);
+		const assetSpotMarket = this.getSpotMarketAccountOrThrow(assetMarketIndex);
 
 		const liabilityTokenProgram =
 			this.getTokenProgramForSpotMarket(liabilitySpotMarket);
@@ -8512,16 +8866,14 @@ export class VelocityClient {
 					accounts: {
 						state: await this.getStatePublicKey(),
 						user: userAccountPublicKey,
-						userStats: userStatsAccountPublicKey,
 						liquidator: liquidatorAccountPublicKey,
-						liquidatorStats: liquidatorStatsPublicKey,
 						authority: this.wallet.publicKey,
 						liabilitySpotMarketVault: liabilitySpotMarket.vault,
 						assetSpotMarketVault: assetSpotMarket.vault,
 						assetTokenAccount: assetTokenAccount,
 						liabilityTokenAccount: liabilityTokenAccount,
 						tokenProgram: assetTokenProgram,
-						driftSigner: this.getStateAccount().signer,
+						velocitySigner: this.getStateAccount().signer,
 						instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
 					},
 					remainingAccounts,
@@ -8535,115 +8887,14 @@ export class VelocityClient {
 				accounts: {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
-					userStats: userStatsAccountPublicKey,
 					liquidator: liquidatorAccountPublicKey,
-					liquidatorStats: liquidatorStatsPublicKey,
 					authority: this.wallet.publicKey,
 					liabilitySpotMarketVault: liabilitySpotMarket.vault,
 					assetSpotMarketVault: assetSpotMarket.vault,
 					assetTokenAccount: assetTokenAccount,
 					liabilityTokenAccount: liabilityTokenAccount,
 					tokenProgram: assetTokenProgram,
-					driftSigner: this.getStateAccount().signer,
-					instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
-				},
-				remainingAccounts,
-			}
-		);
-
-		return { beginSwapIx, endSwapIx };
-	}
-
-	public async getInsuranceFundSwapIx({
-		inMarketIndex,
-		outMarketIndex,
-		amountIn,
-		inTokenAccount,
-		outTokenAccount,
-	}: {
-		inMarketIndex: number;
-		outMarketIndex: number;
-		amountIn: BN;
-		inTokenAccount: PublicKey;
-		outTokenAccount: PublicKey;
-	}): Promise<{
-		beginSwapIx: TransactionInstruction;
-		endSwapIx: TransactionInstruction;
-	}> {
-		const remainingAccounts = await this.getRemainingAccounts({
-			userAccounts: [],
-			writableSpotMarketIndexes: [inMarketIndex, outMarketIndex],
-		});
-
-		const inSpotMarket = this.getSpotMarketAccount(inMarketIndex);
-		const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
-
-		if (this.isToken2022(inSpotMarket) || this.isToken2022(outSpotMarket)) {
-			remainingAccounts.push({
-				pubkey: inSpotMarket.mint,
-				isWritable: false,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: outSpotMarket.mint,
-				isWritable: false,
-				isSigner: false,
-			});
-			if (this.isTransferHook(inSpotMarket)) {
-				this.addExtraAccountMetasToRemainingAccounts(
-					inSpotMarket.mint,
-					remainingAccounts
-				);
-			}
-			if (this.isTransferHook(outSpotMarket)) {
-				this.addExtraAccountMetasToRemainingAccounts(
-					outSpotMarket.mint,
-					remainingAccounts
-				);
-			}
-		}
-
-		const ifRebalanceConfig = getIfRebalanceConfigPublicKey(
-			this.program.programId,
-			inMarketIndex,
-			outMarketIndex
-		);
-
-		const beginSwapIx = await this.program.instruction.beginInsuranceFundSwap(
-			inMarketIndex,
-			outMarketIndex,
-			amountIn,
-			{
-				accounts: {
-					state: await this.getStatePublicKey(),
-					authority: this.wallet.publicKey,
-					outInsuranceFundVault: outSpotMarket.insuranceFund.vault,
-					inInsuranceFundVault: inSpotMarket.insuranceFund.vault,
-					outTokenAccount,
-					inTokenAccount,
-					ifRebalanceConfig: ifRebalanceConfig,
-					tokenProgram: TOKEN_PROGRAM_ID,
-					driftSigner: this.getStateAccount().signer,
-					instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
-				},
-				remainingAccounts,
-			}
-		);
-
-		const endSwapIx = await this.program.instruction.endInsuranceFundSwap(
-			inMarketIndex,
-			outMarketIndex,
-			{
-				accounts: {
-					state: await this.getStatePublicKey(),
-					authority: this.wallet.publicKey,
-					outInsuranceFundVault: outSpotMarket.insuranceFund.vault,
-					inInsuranceFundVault: inSpotMarket.insuranceFund.vault,
-					outTokenAccount,
-					inTokenAccount,
-					ifRebalanceConfig: ifRebalanceConfig,
-					tokenProgram: TOKEN_PROGRAM_ID,
-					driftSigner: this.getStateAccount().signer,
+					velocitySigner: this.getStateAccount().signer,
 					instructions: SYSVAR_INSTRUCTIONS_PUBKEY,
 				},
 				remainingAccounts,
@@ -8679,8 +8930,8 @@ export class VelocityClient {
 			[],
 			this.opts
 		);
-		this.perpMarketLastSlotCache.set(perpMarketIndex, slot);
-		this.spotMarketLastSlotCache.set(liabilityMarketIndex, slot);
+		this.cachePerpMarketSlot(slot, perpMarketIndex);
+		this.cacheSpotMarketSlot(slot, liabilityMarketIndex);
 		return txSig;
 	}
 
@@ -8704,7 +8955,10 @@ export class VelocityClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				this.getUserAccountOrThrow(liquidatorSubAccountId),
+				userAccount,
+			],
 			writablePerpMarketIndexes: [perpMarketIndex],
 			writableSpotMarketIndexes: [liabilityMarketIndex],
 		});
@@ -8754,8 +9008,8 @@ export class VelocityClient {
 			[],
 			this.opts
 		);
-		this.perpMarketLastSlotCache.set(perpMarketIndex, slot);
-		this.spotMarketLastSlotCache.set(assetMarketIndex, slot);
+		this.cachePerpMarketSlot(slot, perpMarketIndex);
+		this.cacheSpotMarketSlot(slot, assetMarketIndex);
 		return txSig;
 	}
 
@@ -8779,7 +9033,10 @@ export class VelocityClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				this.getUserAccountOrThrow(liquidatorSubAccountId),
+				userAccount,
+			],
 			writablePerpMarketIndexes: [perpMarketIndex],
 			writableSpotMarketIndexes: [assetMarketIndex],
 		});
@@ -8843,7 +9100,10 @@ export class VelocityClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				this.getUserAccountOrThrow(liquidatorSubAccountId),
+				userAccount,
+			],
 			writablePerpMarketIndexes: [marketIndex],
 			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
@@ -8863,7 +9123,7 @@ export class VelocityClient {
 					liquidatorStats: liquidatorStatsPublicKey,
 					spotMarketVault: spotMarket.vault,
 					insuranceFundVault: spotMarket.insuranceFund.vault,
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 					tokenProgram: TOKEN_PROGRAM_ID,
 				},
 				remainingAccounts: remainingAccounts,
@@ -8910,11 +9170,14 @@ export class VelocityClient {
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(liquidatorSubAccountId), userAccount],
+			userAccounts: [
+				this.getUserAccountOrThrow(liquidatorSubAccountId),
+				userAccount,
+			],
 			writableSpotMarketIndexes: [marketIndex],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		const tokenProgramId = this.getTokenProgramForSpotMarket(spotMarket);
 
 		this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
@@ -8935,7 +9198,7 @@ export class VelocityClient {
 				liquidator,
 				spotMarketVault: spotMarket.vault,
 				insuranceFundVault: spotMarket.insuranceFund.vault,
-				driftSigner: this.getSignerPublicKey(),
+				velocitySigner: this.getSignerPublicKey(),
 				tokenProgram: tokenProgramId,
 			},
 			remainingAccounts: remainingAccounts,
@@ -8993,17 +9256,17 @@ export class VelocityClient {
 	public async getUpdatePrelaunchOracleIx(
 		perpMarketIndex: number
 	): Promise<TransactionInstruction> {
-		const perpMarket = this.getPerpMarketAccount(perpMarketIndex);
+		const perpMarket = this.getPerpMarketAccountOrThrow(perpMarketIndex);
 
-		if (!isVariant(perpMarket.amm.oracleSource, 'prelaunch')) {
-			throw new Error(`Wrong oracle source ${perpMarket.amm.oracleSource}`);
+		if (!isVariant(perpMarket.oracleSource, 'prelaunch')) {
+			throw new Error(`Wrong oracle source ${perpMarket.oracleSource}`);
 		}
 
 		return await this.program.instruction.updatePrelaunchOracle({
 			accounts: {
 				state: await this.getStatePublicKey(),
 				perpMarket: perpMarket.pubkey,
-				oracle: perpMarket.amm.oracle,
+				oracle: perpMarket.oracle,
 			},
 		});
 	}
@@ -9028,7 +9291,7 @@ export class VelocityClient {
 		perpMarketIndex: number,
 		makers: [PublicKey, PublicKey][]
 	): Promise<TransactionInstruction> {
-		const perpMarket = this.getPerpMarketAccount(perpMarketIndex);
+		const perpMarket = this.getPerpMarketAccountOrThrow(perpMarketIndex);
 
 		const remainingAccounts = [];
 		for (const [maker, makerStats] of makers) {
@@ -9048,7 +9311,7 @@ export class VelocityClient {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				perpMarket: perpMarket.pubkey,
-				oracle: perpMarket.amm.oracle,
+				oracle: perpMarket.oracle,
 				authority: this.wallet.publicKey,
 				keeperStats: this.getUserStatsAccountPublicKey(),
 			},
@@ -9107,23 +9370,28 @@ export class VelocityClient {
 	}
 
 	public getOracleDataForPerpMarket(marketIndex: number): OraclePriceData {
-		return this.accountSubscriber.getOraclePriceDataAndSlotForPerpMarket(
-			marketIndex
-		).data;
+		const oraclePriceDataAndSlot =
+			this.accountSubscriber.getOraclePriceDataAndSlotForPerpMarket(
+				marketIndex
+			);
+		if (!oraclePriceDataAndSlot) {
+			throw new Error(`No oracle price data for perp market ${marketIndex}`);
+		}
+		return oraclePriceDataAndSlot.data;
 	}
 
 	public getMMOracleDataForPerpMarket(marketIndex: number): MMOraclePriceData {
-		const perpMarket = this.getPerpMarketAccount(marketIndex);
+		const perpMarket = this.getPerpMarketAccountOrThrow(marketIndex);
 		const oracleData = this.getOracleDataForPerpMarket(marketIndex);
 		const stateAccountAndSlot = this.accountSubscriber.getStateAccountAndSlot();
-		const isMMOracleActive = !perpMarket.amm.mmOracleSlot.eq(ZERO);
-		const pctDiff = perpMarket.amm.mmOraclePrice
+		const isMMOracleActive = !perpMarket.marketStats.mmOracleSlot.eq(ZERO);
+		const pctDiff = perpMarket.marketStats.mmOraclePrice
 			.sub(oracleData.price)
 			.abs()
 			.mul(PERCENTAGE_PRECISION)
 			.div(BN.max(oracleData.price, ONE));
 
-		const mmOracleSequenceId = perpMarket.amm.mmOracleSequenceId;
+		const mmOracleSequenceId = perpMarket.marketStats.mmOracleSequenceId;
 
 		// Do slot check for recency if sequence ids are zero or they're too divergent
 		const doSlotCheckForRecency =
@@ -9131,48 +9399,49 @@ export class VelocityClient {
 			oracleData.sequenceId.eq(ZERO) ||
 			mmOracleSequenceId.eq(ZERO) ||
 			oracleData.sequenceId
-				.sub(perpMarket.amm.mmOracleSequenceId)
+				.sub(perpMarket.marketStats.mmOracleSequenceId)
 				.abs()
 				.gt(oracleData.sequenceId.div(new BN(10_000)));
 
 		let isExchangeOracleMoreRecent = true;
 		if (
 			doSlotCheckForRecency &&
-			oracleData.slot <= perpMarket.amm.mmOracleSlot
+			oracleData.slot.lte(perpMarket.marketStats.mmOracleSlot)
 		) {
 			isExchangeOracleMoreRecent = false;
 		} else if (
 			!doSlotCheckForRecency &&
-			oracleData.sequenceId < mmOracleSequenceId
+			oracleData.sequenceId != null &&
+			oracleData.sequenceId.lt(mmOracleSequenceId)
 		) {
 			isExchangeOracleMoreRecent = false;
 		}
 
 		const conf = getOracleConfidenceFromMMOracleData(
-			perpMarket.amm.mmOraclePrice,
+			perpMarket.marketStats.mmOraclePrice,
 			oracleData
 		);
 
 		if (
 			isOracleTooDivergent(
-				perpMarket.amm,
+				perpMarket.marketStats,
 				{
-					price: perpMarket.amm.mmOraclePrice,
-					slot: perpMarket.amm.mmOracleSlot,
+					price: perpMarket.marketStats.mmOraclePrice,
+					slot: perpMarket.marketStats.mmOracleSlot,
 					confidence: conf,
 					hasSufficientNumberOfDataPoints: true,
 				},
 				stateAccountAndSlot.data.oracleGuardRails
 			) ||
-			perpMarket.amm.mmOraclePrice.eq(ZERO) ||
+			perpMarket.marketStats.mmOraclePrice.eq(ZERO) ||
 			isExchangeOracleMoreRecent ||
 			pctDiff.gt(PERCENTAGE_PRECISION.divn(100)) // 1% threshold
 		) {
 			return { ...oracleData, isMMOracleActive };
 		} else {
 			return {
-				price: perpMarket.amm.mmOraclePrice,
-				slot: perpMarket.amm.mmOracleSlot,
+				price: perpMarket.marketStats.mmOraclePrice,
+				slot: perpMarket.marketStats.mmOracleSlot,
 				confidence: conf,
 				hasSufficientNumberOfDataPoints: true,
 				isMMOracleActive,
@@ -9181,9 +9450,14 @@ export class VelocityClient {
 	}
 
 	public getOracleDataForSpotMarket(marketIndex: number): OraclePriceData {
-		return this.accountSubscriber.getOraclePriceDataAndSlotForSpotMarket(
-			marketIndex
-		).data;
+		const oraclePriceDataAndSlot =
+			this.accountSubscriber.getOraclePriceDataAndSlotForSpotMarket(
+				marketIndex
+			);
+		if (!oraclePriceDataAndSlot) {
+			throw new Error(`No oracle price data for spot market ${marketIndex}`);
+		}
+		return oraclePriceDataAndSlot.data;
 	}
 
 	public async initializeInsuranceFundStake(
@@ -9212,7 +9486,7 @@ export class VelocityClient {
 
 		const accounts = {
 			insuranceFundStake: ifStakeAccountPublicKey,
-			spotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+			spotMarket: this.getSpotMarketAccountOrThrow(marketIndex).pubkey,
 			userStats: getUserStatsAccountPublicKey(
 				this.program.programId,
 				this.wallet.publicKey // only allow payer to initialize own insurance fund stake account
@@ -9237,14 +9511,14 @@ export class VelocityClient {
 		amount: BN,
 		collateralAccountPublicKey: PublicKey
 	): Promise<TransactionInstruction> {
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
 			marketIndex
 		);
 
-		const remainingAccounts = [];
+		const remainingAccounts: AccountMeta[] = [];
 		this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
 		if (this.isTransferHook(spotMarket)) {
 			await this.addExtraAccountMetasToRemainingAccounts(
@@ -9269,7 +9543,7 @@ export class VelocityClient {
 					authority: this.wallet.publicKey,
 					spotMarketVault: spotMarket.vault,
 					insuranceFundVault: spotMarket.insuranceFund.vault,
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 					userTokenAccount: collateralAccountPublicKey,
 					tokenProgram,
 				},
@@ -9360,7 +9634,7 @@ export class VelocityClient {
 	}): Promise<TransactionInstruction[]> {
 		const addIfStakeIxs = [];
 
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
 		const createWSOLTokenAccount =
 			isSolMarket && collateralAccountPublicKey.equals(this.wallet.publicKey);
@@ -9453,7 +9727,7 @@ export class VelocityClient {
 		amount: BN,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
@@ -9486,7 +9760,7 @@ export class VelocityClient {
 		marketIndex: number,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
@@ -9521,7 +9795,7 @@ export class VelocityClient {
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const removeIfStakeIxs = [];
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
@@ -9561,7 +9835,7 @@ export class VelocityClient {
 			}
 		}
 
-		const remainingAccounts = [];
+		const remainingAccounts: AccountMeta[] = [];
 		this.addTokenMintToRemainingAccounts(spotMarketAccount, remainingAccounts);
 		if (this.isTransferHook(spotMarketAccount)) {
 			await this.addExtraAccountMetasToRemainingAccounts(
@@ -9583,7 +9857,7 @@ export class VelocityClient {
 					),
 					authority: this.wallet.publicKey,
 					insuranceFundVault: spotMarketAccount.insuranceFund.vault,
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 					userTokenAccount: tokenAccount,
 					tokenProgram,
 				},
@@ -9630,7 +9904,7 @@ export class VelocityClient {
 		authority: PublicKey
 	): Promise<TransactionInstruction> {
 		const marketIndex = QUOTE_SPOT_MARKET_INDEX;
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
 			authority,
@@ -9655,45 +9929,6 @@ export class VelocityClient {
 		return ix;
 	}
 
-	public async updateUserGovTokenInsuranceStake(
-		authority: PublicKey,
-		txParams?: TxParams
-	): Promise<TransactionSignature> {
-		const ix = await this.getUpdateUserGovTokenInsuranceStakeIx(authority);
-		const tx = await this.buildTransaction(ix, txParams);
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
-		return txSig;
-	}
-
-	public async getUpdateUserGovTokenInsuranceStakeIx(
-		authority: PublicKey
-	): Promise<TransactionInstruction> {
-		const marketIndex = GOV_SPOT_MARKET_INDEX;
-		const spotMarket = this.getSpotMarketAccount(marketIndex);
-		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
-			this.program.programId,
-			authority,
-			marketIndex
-		);
-		const userStatsPublicKey = getUserStatsAccountPublicKey(
-			this.program.programId,
-			authority
-		);
-
-		const ix = this.program.instruction.updateUserGovTokenInsuranceStake({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				spotMarket: spotMarket.pubkey,
-				insuranceFundStake: ifStakeAccountPublicKey,
-				userStats: userStatsPublicKey,
-				signer: this.wallet.publicKey,
-				insuranceFundVault: spotMarket.insuranceFund.vault,
-			},
-		});
-
-		return ix;
-	}
-
 	public async settleRevenueToInsuranceFund(
 		spotMarketIndex: number,
 		txParams?: TxParams
@@ -9708,10 +9943,10 @@ export class VelocityClient {
 	public async getSettleRevenueToInsuranceFundIx(
 		spotMarketIndex: number
 	): Promise<TransactionInstruction> {
-		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(spotMarketIndex);
 		const tokenProgramId = this.getTokenProgramForSpotMarket(spotMarketAccount);
 
-		const remainingAccounts = [];
+		const remainingAccounts: AccountMeta[] = [];
 		this.addTokenMintToRemainingAccounts(spotMarketAccount, remainingAccounts);
 		if (this.isTransferHook(spotMarketAccount)) {
 			await this.addExtraAccountMetasToRemainingAccounts(
@@ -9727,7 +9962,7 @@ export class VelocityClient {
 					state: await this.getStatePublicKey(),
 					spotMarket: spotMarketAccount.pubkey,
 					spotMarketVault: spotMarketAccount.vault,
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 					insuranceFundVault: spotMarketAccount.insuranceFund.vault,
 					tokenProgram: tokenProgramId,
 				},
@@ -9737,6 +9972,40 @@ export class VelocityClient {
 		return ix;
 	}
 
+	public async sweepPerpMarketFees(
+		perpMarketIndex: number,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const tx = await this.buildTransaction(
+			await this.getSweepPerpMarketFeesIx(perpMarketIndex),
+			txParams
+		);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
+
+	public async getSweepPerpMarketFeesIx(
+		perpMarketIndex: number
+	): Promise<TransactionInstruction> {
+		const perpMarketAccount = this.getPerpMarketAccountOrThrow(perpMarketIndex);
+		const spotMarketAccount = this.getSpotMarketAccountOrThrow(
+			perpMarketAccount.quoteSpotMarketIndex
+		);
+
+		const ix = await this.program.instruction.sweepPerpMarketFees(
+			perpMarketIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					perpMarket: perpMarketAccount.pubkey,
+					spotMarket: spotMarketAccount.pubkey,
+					oracle: perpMarketAccount.oracle,
+				},
+			}
+		);
+		return ix;
+	}
+
 	public async resolvePerpPnlDeficit(
 		spotMarketIndex: number,
 		perpMarketIndex: number,
@@ -9758,12 +10027,12 @@ export class VelocityClient {
 		perpMarketIndex: number
 	): Promise<TransactionInstruction> {
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
+			userAccounts: [],
 			writablePerpMarketIndexes: [perpMarketIndex],
 			writableSpotMarketIndexes: [spotMarketIndex],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(spotMarketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(spotMarketIndex);
 		const tokenProgramId = this.getTokenProgramForSpotMarket(spotMarket);
 
 		return await this.program.instruction.resolvePerpPnlDeficit(
@@ -9775,7 +10044,7 @@ export class VelocityClient {
 					authority: this.wallet.publicKey,
 					spotMarketVault: spotMarket.vault,
 					insuranceFundVault: spotMarket.insuranceFund.vault,
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 					tokenProgram: tokenProgramId,
 				},
 				remainingAccounts: remainingAccounts,
@@ -9788,9 +10057,9 @@ export class VelocityClient {
 		amount: BN,
 		userTokenAccountPublicKey: PublicKey
 	): Promise<TransactionInstruction> {
-		const spotMarket = await this.getSpotMarketAccount(marketIndex);
+		const spotMarket = await this.getSpotMarketAccountOrThrow(marketIndex);
 
-		const remainingAccounts = [];
+		const remainingAccounts: AccountMeta[] = [];
 		this.addTokenMintToRemainingAccounts(spotMarket, remainingAccounts);
 		if (this.isTransferHook(spotMarket)) {
 			await this.addExtraAccountMetasToRemainingAccounts(
@@ -9818,7 +10087,7 @@ export class VelocityClient {
 	}
 
 	/**
-	 * This ix will donate your funds to drift revenue pool. It does not deposit into your user account
+	 * This ix will donate your funds to velocity revenue pool. It does not deposit into your user account
 	 * @param marketIndex
 	 * @param amount
 	 * @param userTokenAccountPublicKey
@@ -9843,12 +10112,14 @@ export class VelocityClient {
 	public getPerpMarketExtendedInfo(
 		marketIndex: number
 	): PerpMarketExtendedInfo {
-		const marketAccount = this.getPerpMarketAccount(marketIndex);
-		const quoteAccount = this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX);
+		const marketAccount = this.getPerpMarketAccountOrThrow(marketIndex);
+		const quoteAccount = this.getSpotMarketAccountOrThrow(
+			QUOTE_SPOT_MARKET_INDEX
+		);
 
 		const extendedInfo: PerpMarketExtendedInfo = {
 			marketIndex,
-			minOrderSize: marketAccount.amm?.minOrderSize,
+			minOrderSize: marketAccount.marketStats?.minOrderSize,
 			marginMaintenance: marketAccount.marginRatioMaintenance,
 			pnlPoolValue: getTokenAmount(
 				marketAccount.pnlPool?.scaledBalance,
@@ -9891,11 +10162,11 @@ export class VelocityClient {
 			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
 
 		if (marketIndex !== undefined) {
-			let marketAccount = null;
+			let marketAccount: PerpMarketAccount | SpotMarketAccount;
 			if (isVariant(marketType, 'perp')) {
-				marketAccount = this.getPerpMarketAccount(marketIndex);
+				marketAccount = this.getPerpMarketAccountOrThrow(marketIndex);
 			} else {
-				marketAccount = this.getSpotMarketAccount(marketIndex);
+				marketAccount = this.getSpotMarketAccountOrThrow(marketIndex);
 			}
 
 			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
@@ -9993,7 +10264,7 @@ export class VelocityClient {
 	public async getPauseSpotMarketDepositWithdrawIx(
 		spotMarketIndex: number
 	): Promise<TransactionInstruction> {
-		const spotMarket = await this.getSpotMarketAccount(spotMarketIndex);
+		const spotMarket = await this.getSpotMarketAccountOrThrow(spotMarketIndex);
 		return this.program.instruction.pauseSpotMarketDepositWithdraw({
 			accounts: {
 				state: await this.getStatePublicKey(),
@@ -10055,7 +10326,7 @@ export class VelocityClient {
 			programId: this.program.programId,
 			keys: [
 				{
-					pubkey: this.getPerpMarketAccount(marketIndex).pubkey,
+					pubkey: this.getPerpMarketAccountOrThrow(marketIndex).pubkey,
 					isWritable: true,
 					isSigner: false,
 				},
@@ -10111,7 +10382,7 @@ export class VelocityClient {
 			programId: this.program.programId,
 			keys: [
 				{
-					pubkey: this.getPerpMarketAccount(marketIndex).pubkey,
+					pubkey: this.getPerpMarketAccountOrThrow(marketIndex).pubkey,
 					isWritable: true,
 					isSigner: false,
 				},
@@ -10285,7 +10556,7 @@ export class VelocityClient {
 				state: await this.getStatePublicKey(),
 				keeper: this.wallet.publicKey,
 				ammCache: getAmmCachePublicKey(this.program.programId),
-				quoteMarket: this.getSpotMarketAccount(0).pubkey,
+				quoteMarket: this.getSpotMarketAccountOrThrow(0).pubkey,
 			},
 			remainingAccounts,
 		});
@@ -10308,7 +10579,9 @@ export class VelocityClient {
 	public async getUpdateConstituentOracleInfoIx(
 		constituent: ConstituentAccount
 	): Promise<TransactionInstruction> {
-		const spotMarket = this.getSpotMarketAccount(constituent.spotMarketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(
+			constituent.spotMarketIndex
+		);
 		return this.program.instruction.updateConstituentOracleInfo({
 			accounts: {
 				keeper: this.wallet.publicKey,
@@ -10371,11 +10644,11 @@ export class VelocityClient {
 			outMarketIndex
 		);
 		const userInTokenAccount = await getAssociatedTokenAddress(
-			this.getSpotMarketAccount(inMarketIndex).mint,
+			this.getSpotMarketAccountOrThrow(inMarketIndex).mint,
 			userAuthority
 		);
 		const userOutTokenAccount = await getAssociatedTokenAddress(
-			this.getSpotMarketAccount(outMarketIndex).mint,
+			this.getSpotMarketAccountOrThrow(outMarketIndex).mint,
 			userAuthority
 		);
 		const inConstituent = getConstituentPublicKey(
@@ -10388,8 +10661,8 @@ export class VelocityClient {
 			lpPool,
 			outMarketIndex
 		);
-		const inMarketMint = this.getSpotMarketAccount(inMarketIndex).mint;
-		const outMarketMint = this.getSpotMarketAccount(outMarketIndex).mint;
+		const inMarketMint = this.getSpotMarketAccountOrThrow(inMarketIndex).mint;
+		const outMarketMint = this.getSpotMarketAccountOrThrow(outMarketIndex).mint;
 
 		const constituentTargetBase = getConstituentTargetBasePublicKey(
 			this.program.programId,
@@ -10490,7 +10763,7 @@ export class VelocityClient {
 			{
 				remainingAccounts,
 				accounts: {
-					driftSigner: this.getSignerPublicKey(),
+					velocitySigner: this.getSignerPublicKey(),
 					state: await this.getStatePublicKey(),
 					lpPool,
 					constituentTargetBase,
@@ -10587,7 +10860,7 @@ export class VelocityClient {
 			writableSpotMarketIndexes: [inMarketIndex],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(inMarketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
 		const inMarketMint = spotMarket.mint;
 		const isSolMarket = inMarketMint.equals(WRAPPED_SOL_MINT);
 
@@ -10724,7 +10997,7 @@ export class VelocityClient {
 			readableSpotMarketIndexes: [inMarketIndex],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(inMarketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(inMarketIndex);
 		const inMarketMint = spotMarket.mint;
 		const inConstituent = getConstituentPublicKey(
 			this.program.programId,
@@ -10802,7 +11075,7 @@ export class VelocityClient {
 			writableSpotMarketIndexes: [outMarketIndex],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(outMarketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
 		const outMarketMint = spotMarket.mint;
 		const outConstituent = getConstituentPublicKey(
 			this.program.programId,
@@ -10848,7 +11121,7 @@ export class VelocityClient {
 				{
 					remainingAccounts,
 					accounts: {
-						driftSigner: this.getSignerPublicKey(),
+						velocitySigner: this.getSignerPublicKey(),
 						state: await this.getStatePublicKey(),
 						lpPool: lpPool.pubkey,
 						authority: this.wallet.publicKey,
@@ -10913,7 +11186,7 @@ export class VelocityClient {
 			writableSpotMarketIndexes: [outMarketIndex],
 		});
 
-		const spotMarket = this.getSpotMarketAccount(outMarketIndex);
+		const spotMarket = this.getSpotMarketAccountOrThrow(outMarketIndex);
 		const outMarketMint = spotMarket.mint;
 		const outConstituent = getConstituentPublicKey(
 			this.program.programId,
@@ -11013,7 +11286,7 @@ export class VelocityClient {
 			...(await this.getAllSettlePerpToLpPoolIxs(
 				lpPool.lpPoolId,
 				this.getPerpMarketAccounts()
-					.filter((marketAccount) => marketAccount.lpStatus > 0)
+					.filter((marketAccount) => marketAccount.hedgeConfig.status > 0)
 					.map((marketAccount) => marketAccount.marketIndex)
 			))
 		);
@@ -11152,7 +11425,7 @@ export class VelocityClient {
 		remainingAccounts.push(
 			...perpMarketIndexes.map((index) => {
 				return {
-					pubkey: this.getPerpMarketAccount(index).pubkey,
+					pubkey: this.getPerpMarketAccountOrThrow(index).pubkey,
 					isSigner: false,
 					isWritable: true,
 				};
@@ -11162,7 +11435,7 @@ export class VelocityClient {
 		const lpPool = getLpPoolPublicKey(this.program.programId, lpPoolId);
 		return this.program.instruction.settlePerpToLpPool({
 			accounts: {
-				driftSigner: this.getSignerPublicKey(),
+				velocitySigner: this.getSignerPublicKey(),
 				state: await this.getStatePublicKey(),
 				keeper: this.wallet.publicKey,
 				ammCache: getAmmCachePublicKey(this.program.programId),
@@ -11276,7 +11549,7 @@ export class VelocityClient {
 		txVersion?: TransactionVersion,
 		lookupTables?: AddressLookupTableAccount[],
 		forceVersionedTransaction?: boolean
-	): Promise<(Transaction | VersionedTransaction)[]> {
+	): Promise<(Transaction | VersionedTransaction | undefined)[]> {
 		return this.txHandler.buildBulkTransactions({
 			instructions,
 			txVersion: txVersion ?? this.txVersion,
@@ -11338,9 +11611,9 @@ export class VelocityClient {
 
 	isOrderIncreasingPosition(
 		orderParams: OptionalOrderParams,
-		subAccountId: number
+		subAccountId?: number
 	): boolean {
-		const userAccount = this.getUserAccount(subAccountId);
+		const userAccount = this.getUserAccountOrThrow(subAccountId);
 		const perpPosition = userAccount.perpPositions.find(
 			(p) => p.marketIndex === orderParams.marketIndex
 		);
@@ -11356,9 +11629,3 @@ export class VelocityClient {
 		return currentBase.add(orderBaseAmount).abs().gt(currentBase.abs());
 	}
 }
-
-/** @deprecated Use `VelocityClient` instead. `DriftClient` will be removed in a future major. */
-export const DriftClient = VelocityClient;
-
-/** @deprecated Use `VelocityClient` instead. `DriftClient` will be removed in a future major. */
-export type DriftClient = VelocityClient;