@drift-labs/sdk 2.41.0-beta.0 → 2.41.0-beta.1

package/src/accounts/webSocketAccountSubscriber.ts

@@ -13,17 +13,24 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	decodeBufferFn: (buffer: Buffer) => T;
 	onChange: (data: T) => void;
 	listenerId?: number;
+	resubTimeoutMs?: number;
+	timeoutId?: NodeJS.Timeout;
+
+	receivingData: boolean;
 
 	public constructor(
 		accountName: string,
 		program: Program,
 		accountPublicKey: PublicKey,
-		decodeBuffer?: (buffer: Buffer) => T
+		decodeBuffer?: (buffer: Buffer) => T,
+		resubTimeoutMs?: number
 	) {
 		this.accountName = accountName;
 		this.program = program;
 		this.accountPublicKey = accountPublicKey;
 		this.decodeBufferFn = decodeBuffer;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.receivingData = false;
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
@@ -39,10 +46,21 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		this.listenerId = this.program.provider.connection.onAccountChange(
 			this.accountPublicKey,
 			(accountInfo, context) => {
-				this.handleRpcResponse(context, accountInfo);
+				if (this.resubTimeoutMs) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.handleRpcResponse(context, accountInfo);
+					this.setTimeout();
+				} else {
+					this.handleRpcResponse(context, accountInfo);
+				}
 			},
 			(this.program.provider as AnchorProvider).opts.commitment
 		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
 	}
 
 	setData(data: T, slot?: number): void {
@@ -57,6 +75,22 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		};
 	}
 
+	private setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(async () => {
+			if (this.receivingData) {
+				console.log(
+					`No ws data from ${this.accountName} in ${this.resubTimeoutMs}ms, resubscribing`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				await this.subscribe(this.onChange);
+			}
+		}, this.resubTimeoutMs);
+	}
+
 	async fetch(): Promise<void> {
 		const rpcResponse =
 			await this.program.provider.connection.getAccountInfoAndContext(

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -31,6 +31,7 @@ export class WebSocketDriftClientAccountSubscriber
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
+	resubTimeoutMs?: number;
 	shouldFindAllMarketsAndOracles: boolean;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
@@ -54,7 +55,8 @@ export class WebSocketDriftClientAccountSubscriber
 		perpMarketIndexes: number[],
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
-		shouldFindAllMarketsAndOracles: boolean
+		shouldFindAllMarketsAndOracles: boolean,
+		resubTimeoutMs?: number
 	) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -63,6 +65,7 @@ export class WebSocketDriftClientAccountSubscriber
 		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<boolean> {
@@ -96,7 +99,9 @@ export class WebSocketDriftClientAccountSubscriber
 		this.stateAccountSubscriber = new WebSocketAccountSubscriber(
 			'state',
 			this.program,
-			statePublicKey
+			statePublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await this.stateAccountSubscriber.subscribe((data: StateAccount) => {
 			this.eventEmitter.emit('stateAccountUpdate', data);
@@ -136,7 +141,9 @@ export class WebSocketDriftClientAccountSubscriber
 		const accountSubscriber = new WebSocketAccountSubscriber<PerpMarketAccount>(
 			'perpMarket',
 			this.program,
-			perpMarketPublicKey
+			perpMarketPublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
 			this.eventEmitter.emit('perpMarketAccountUpdate', data);
@@ -161,7 +168,9 @@ export class WebSocketDriftClientAccountSubscriber
 		const accountSubscriber = new WebSocketAccountSubscriber<SpotMarketAccount>(
 			'spotMarket',
 			this.program,
-			marketPublicKey
+			marketPublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
 			this.eventEmitter.emit('spotMarketAccountUpdate', data);
@@ -192,7 +201,8 @@ export class WebSocketDriftClientAccountSubscriber
 			oracleInfo.publicKey,
 			(buffer: Buffer) => {
 				return client.getOraclePriceDataFromBuffer(buffer);
-			}
+			},
+			this.resubTimeoutMs
 		);
 
 		await accountSubscriber.subscribe((data: OraclePriceData) => {

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -0,0 +1,152 @@
+import { DataAndSlot, BufferAndSlot, ProgramAccountSubscriber } from './types';
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import {
+	Commitment,
+	Context,
+	KeyedAccountInfo,
+	MemcmpFilter,
+	PublicKey,
+} from '@solana/web3.js';
+import * as Buffer from 'buffer';
+
+export class WebSocketProgramAccountSubscriber<T>
+	implements ProgramAccountSubscriber<T>
+{
+	subscriptionName: string;
+	accountDiscriminator: string;
+	dataAndSlot?: DataAndSlot<T> & { accountId: PublicKey };
+	bufferAndSlot?: BufferAndSlot;
+	program: Program;
+	decodeBuffer: (accountName: string, ix: Buffer) => T;
+	onChange: (accountId: PublicKey, data: T, context: Context) => void;
+	listenerId?: number;
+	resubTimeoutMs?: number;
+	timeoutId?: NodeJS.Timeout;
+	options: { filters: MemcmpFilter[]; commitment?: Commitment };
+
+	receivingData = false;
+
+	public constructor(
+		subscriptionName: string,
+		accountDiscriminator: string,
+		program: Program,
+		decodeBufferFn: (accountName: string, ix: Buffer) => T,
+		options: { filters: MemcmpFilter[]; commitment?: Commitment } = {
+			filters: [],
+		},
+		resubTimeoutMs?: number
+	) {
+		this.subscriptionName = subscriptionName;
+		this.accountDiscriminator = accountDiscriminator;
+		this.program = program;
+		this.decodeBuffer = decodeBufferFn;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.options = options;
+		this.receivingData = false;
+	}
+
+	async subscribe(
+		onChange: (accountId: PublicKey, data: T, context: Context) => void
+	): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
+		this.onChange = onChange;
+
+		this.listenerId = this.program.provider.connection.onProgramAccountChange(
+			this.program.programId,
+			(keyedAccountInfo, context) => {
+				if (this.resubTimeoutMs) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.handleRpcResponse(context, keyedAccountInfo);
+					this.setTimeout();
+				} else {
+					this.handleRpcResponse(context, keyedAccountInfo);
+				}
+			},
+			this.options.commitment ??
+				(this.program.provider as AnchorProvider).opts.commitment,
+			this.options.filters
+		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(async () => {
+			if (this.receivingData) {
+				console.log(
+					`No ws data from ${this.subscriptionName} in ${this.resubTimeoutMs}ms, resubscribing`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				await this.subscribe(this.onChange);
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	handleRpcResponse(
+		context: Context,
+		keyedAccountInfo: KeyedAccountInfo
+	): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (keyedAccountInfo) {
+			newBuffer = keyedAccountInfo.accountInfo.data;
+		}
+
+		if (!this.bufferAndSlot) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+				this.dataAndSlot = {
+					data: account,
+					slot: newSlot,
+					accountId: keyedAccountInfo.accountId,
+				};
+				this.onChange(keyedAccountInfo.accountId, account, context);
+			}
+			return;
+		}
+
+		if (newSlot <= this.bufferAndSlot.slot) {
+			return;
+		}
+
+		const oldBuffer = this.bufferAndSlot.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+			this.dataAndSlot = {
+				data: account,
+				slot: newSlot,
+				accountId: keyedAccountInfo.accountId,
+			};
+			this.onChange(keyedAccountInfo.accountId, account, context);
+		}
+	}
+
+	unsubscribe(): Promise<void> {
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
+	}
+}

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -14,17 +14,23 @@ import { UserAccount } from '../types';
 
 export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 	userAccountPublicKey: PublicKey;
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 
-	public constructor(program: Program, userAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userAccountPublicKey = userAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userAccount?: UserAccount): Promise<boolean> {
@@ -35,7 +41,9 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 		this.userDataAccountSubscriber = new WebSocketAccountSubscriber(
 			'user',
 			this.program,
-			this.userAccountPublicKey
+			this.userAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userAccount) {

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -16,17 +16,23 @@ export class WebSocketUserStatsAccountSubscriber
 	implements UserStatsAccountSubscriber
 {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
 	userStatsAccountPublicKey: PublicKey;
 
 	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
 
-	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean> {
@@ -37,7 +43,9 @@ export class WebSocketUserStatsAccountSubscriber
 		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
 			'userStats',
 			this.program,
-			this.userStatsAccountPublicKey
+			this.userStatsAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userStatsAccount) {

package/src/addresses/pda.ts

@@ -214,3 +214,12 @@ export function getReferrerNamePublicKeySync(
 		programId
 	)[0];
 }
+
+export function getProtocolIfSharesTransferConfigPublicKey(
+	programId: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('if_shares_transfer_config'))],
+		programId
+	)[0];
+}

package/src/adminClient.ts

@@ -25,6 +25,7 @@ import {
 	getSerumOpenOrdersPublicKey,
 	getSerumFulfillmentConfigPublicKey,
 	getPhoenixFulfillmentConfigPublicKey,
+	getProtocolIfSharesTransferConfigPublicKey,
 } from './addresses/pda';
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
@@ -1516,4 +1517,35 @@ export class AdminClient extends DriftClient {
 			}
 		);
 	}
+
+	public async initializeProtocolIfSharesTransferConfig(): Promise<TransactionSignature> {
+		return await this.program.rpc.initializeProtocolIfSharesTransferConfig({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				rent: SYSVAR_RENT_PUBKEY,
+				systemProgram: anchor.web3.SystemProgram.programId,
+				protocolIfSharesTransferConfig:
+					getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
+			},
+		});
+	}
+
+	public async updateProtocolIfSharesTransferConfig(
+		whitelistedSigners?: PublicKey[],
+		maxTransferPerEpoch?: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateProtocolIfSharesTransferConfig(
+			whitelistedSigners || null,
+			maxTransferPerEpoch,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					protocolIfSharesTransferConfig:
+						getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
+				},
+			}
+		);
+	}
 }

package/src/auctionSubscriber/auctionSubscriber.ts

@@ -4,48 +4,57 @@ import { getUserFilter, getUserWithAuctionFilter } from '../memcmp';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
-import { ConfirmOptions } from '@solana/web3.js';
+import { ConfirmOptions, Context, PublicKey } from '@solana/web3.js';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 
 export class AuctionSubscriber {
 	private driftClient: DriftClient;
 	private opts: ConfirmOptions;
+	private resubTimeoutMs?: number;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
-	private websocketId: number;
-
-	constructor({ driftClient, opts }: AuctionSubscriberConfig) {
+	constructor({ driftClient, opts, resubTimeoutMs }: AuctionSubscriberConfig) {
 		this.driftClient = driftClient;
 		this.opts = opts || this.driftClient.opts;
 		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe() {
-		this.websocketId = this.driftClient.connection.onProgramAccountChange(
-			this.driftClient.program.programId,
-			(keyAccountInfo, context) => {
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						keyAccountInfo.accountInfo.data
-					) as UserAccount;
+		if (!this.subscriber) {
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'AuctionSubscriber',
+				'User',
+				this.driftClient.program,
+				this.driftClient.program.account.user.coder.accounts.decode.bind(
+					this.driftClient.program.account.user.coder.accounts
+				),
+				{
+					filters: [getUserFilter(), getUserWithAuctionFilter()],
+					commitment: this.driftClient.opts.commitment,
+				},
+				this.resubTimeoutMs
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, data: UserAccount, context: Context) => {
 				this.eventEmitter.emit(
 					'onAccountUpdate',
-					userAccount,
-					keyAccountInfo.accountId,
+					data,
+					accountId,
 					context.slot
 				);
-			},
-			this.driftClient.opts.commitment,
-			[getUserFilter(), getUserWithAuctionFilter()]
+			}
 		);
 	}
 
 	public async unsubscribe() {
-		if (this.websocketId) {
-			await this.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
+		if (!this.subscriber) {
+			return;
 		}
+		this.subscriber.unsubscribe();
 	}
 }

package/src/auctionSubscriber/types.ts

@@ -5,6 +5,7 @@ import { ConfirmOptions, PublicKey } from '@solana/web3.js';
 export type AuctionSubscriberConfig = {
 	driftClient: DriftClient;
 	opts?: ConfirmOptions;
+	resubTimeoutMs?: number;
 };
 
 export interface AuctionSubscriberEvents {

package/src/dlob/DLOB.ts

@@ -675,7 +675,7 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			takingOrderGenerator,
-			this.getMakerLimitBids.bind(this),
+			this.getRestingLimitBids.bind(this),
 			(takerPrice, makerPrice) => {
 				if (isVariant(marketType, 'spot')) {
 					if (takerPrice === undefined) {
@@ -687,8 +687,7 @@ export class DLOB {
 					}
 				}
 				return takerPrice === undefined || takerPrice.lte(makerPrice);
-			},
-			fallbackAsk
+			}
 		);
 		for (const takingAskCrossingBid of takingAsksCrossingBids) {
 			nodesToFill.push(takingAskCrossingBid);
@@ -732,7 +731,7 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			takingOrderGenerator,
-			this.getMakerLimitAsks.bind(this),
+			this.getRestingLimitAsks.bind(this),
 			(takerPrice, makerPrice) => {
 				if (isVariant(marketType, 'spot')) {
 					if (takerPrice === undefined) {
@@ -745,8 +744,7 @@ export class DLOB {
 				}
 
 				return takerPrice === undefined || takerPrice.gte(makerPrice);
-			},
-			fallbackBid
+			}
 		);
 
 		for (const takingBidToFill of takingBidsToFill) {
@@ -790,11 +788,9 @@ export class DLOB {
 			marketIndex: number,
 			slot: number,
 			marketType: MarketType,
-			oraclePriceData: OraclePriceData,
-			fallbackPrice?: BN
+			oraclePriceData: OraclePriceData
 		) => Generator<DLOBNode>,
-		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean,
-		fallbackPrice?: BN
+		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -803,8 +799,7 @@ export class DLOB {
 				marketIndex,
 				slot,
 				marketType,
-				oraclePriceData,
-				fallbackPrice
+				oraclePriceData
 			);
 
 			for (const makerNode of makerNodeGenerator) {
@@ -1714,8 +1709,6 @@ export class DLOB {
 	 * @param slot
 	 * @param oraclePriceData
 	 * @param depth how many levels of the order book to return
-	 * @param fallbackAsk best ask for fallback liquidity, only relevant for perps
-	 * @param fallbackBid best bid for fallback liquidity, only relevant for perps
 	 * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
 	 */
 	public getL2({
@@ -1724,8 +1717,6 @@ export class DLOB {
 		slot,
 		oraclePriceData,
 		depth,
-		fallbackAsk,
-		fallbackBid,
 		fallbackL2Generators = [],
 	}: {
 		marketIndex: number;
@@ -1733,18 +1724,10 @@ export class DLOB {
 		slot: number;
 		oraclePriceData: OraclePriceData;
 		depth: number;
-		fallbackAsk?: BN;
-		fallbackBid?: BN;
 		fallbackL2Generators?: L2OrderBookGenerator[];
 	}): L2OrderBook {
 		const makerAskL2LevelGenerator = getL2GeneratorFromDLOBNodes(
-			this.getMakerLimitAsks(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData,
-				fallbackBid
-			),
+			this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData),
 			oraclePriceData,
 			slot
 		);
@@ -1765,13 +1748,7 @@ export class DLOB {
 		const asks = createL2Levels(askL2LevelGenerator, depth);
 
 		const makerBidGenerator = getL2GeneratorFromDLOBNodes(
-			this.getMakerLimitBids(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData,
-				fallbackAsk
-			),
+			this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData),
 			oraclePriceData,
 			slot
 		);

package/src/dlob/DLOBSubscriber.ts

@@ -10,12 +10,12 @@ import {
 import { DriftClient } from '../driftClient';
 import { isVariant, MarketType } from '../types';
 import {
+	DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
 	getVammL2Generator,
 	L2OrderBook,
 	L2OrderBookGenerator,
 	L3OrderBook,
 } from './orderBookLevels';
-import { calculateAskPrice, calculateBidPrice } from '../math/market';
 
 export class DLOBSubscriber {
 	driftClient: DriftClient;
@@ -103,8 +103,6 @@ export class DLOBSubscriber {
 		}
 
 		let oraclePriceData;
-		let fallbackBid;
-		let fallbackAsk;
 		const isPerp = isVariant(marketType, 'perp');
 		if (isPerp) {
 			const perpMarketAccount =
@@ -112,19 +110,24 @@ export class DLOBSubscriber {
 			oraclePriceData = this.driftClient.getOracleDataForPerpMarket(
 				perpMarketAccount.marketIndex
 			);
-			fallbackBid = calculateBidPrice(perpMarketAccount, oraclePriceData);
-			fallbackAsk = calculateAskPrice(perpMarketAccount, oraclePriceData);
 		} else {
 			oraclePriceData =
 				this.driftClient.getOracleDataForSpotMarket(marketIndex);
 		}
 
 		if (isPerp && includeVamm) {
+			if (fallbackL2Generators.length > 0) {
+				throw new Error(
+					'includeVamm can only be used if fallbackL2Generators is empty'
+				);
+			}
+
 			fallbackL2Generators = [
 				getVammL2Generator({
 					marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
 					oraclePriceData,
 					numOrders: numVammOrders ?? depth,
+					topOfBookQuoteAmounts: DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
 				}),
 			];
 		}
@@ -135,8 +138,6 @@ export class DLOBSubscriber {
 			depth,
 			oraclePriceData,
 			slot: this.slotSource.getSlot(),
-			fallbackBid,
-			fallbackAsk,
 			fallbackL2Generators: fallbackL2Generators,
 		});
 	}