@drift-labs/sdk 2.49.0-beta.0 → 2.49.0-beta.10

package/src/events/eventSubscriber.ts

@@ -47,7 +47,7 @@ export class EventSubscriber {
 				new EventList(
 					eventType,
 					this.options.maxEventsPerType,
-					getSortFn(this.options.orderBy, this.options.orderDir, eventType),
+					getSortFn(this.options.orderBy, this.options.orderDir),
 					this.options.orderDir
 				)
 			);
@@ -159,6 +159,7 @@ export class EventSubscriber {
 
 		if (!this.lastSeenSlot || slot > this.lastSeenSlot) {
 			this.lastSeenTxSig = txSig;
+			this.lastSeenSlot = slot;
 		}
 
 		if (

package/src/events/sort.ts

@@ -4,10 +4,7 @@ import {
 	EventSubscriptionOrderDirection,
 	EventType,
 	SortFn,
-	Event,
 } from './types';
-import { OrderActionRecord } from '../types';
-import { ZERO } from '../index';
 
 function clientSortAscFn(): 'less than' {
 	return 'less than';
@@ -17,45 +14,26 @@ function clientSortDescFn(): 'greater than' {
 	return 'greater than';
 }
 
-function defaultBlockchainSortFn(
+function blockchainSortFn(
 	currentEvent: EventMap[EventType],
 	newEvent: EventMap[EventType]
 ): 'less than' | 'greater than' {
-	return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
-}
-
-function orderActionRecordSortFn(
-	currentEvent: Event<OrderActionRecord>,
-	newEvent: Event<OrderActionRecord>
-): 'less than' | 'greater than' {
-	const currentEventMarketIndex = currentEvent.marketIndex;
-	const newEventMarketIndex = newEvent.marketIndex;
-	if (currentEventMarketIndex !== newEventMarketIndex) {
-		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
-	}
-
-	if (currentEvent.fillRecordId?.gt(ZERO) && newEvent.fillRecordId?.gt(ZERO)) {
-		return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+	if (currentEvent.slot == newEvent.slot) {
+		return currentEvent.txSigIndex < newEvent.txSigIndex
 			? 'less than'
 			: 'greater than';
-	} else {
-		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
 	}
+
+	return currentEvent.slot < newEvent.slot ? 'less than' : 'greater than';
 }
 
 export function getSortFn(
 	orderBy: EventSubscriptionOrderBy,
-	orderDir: EventSubscriptionOrderDirection,
-	eventType: EventType
+	orderDir: EventSubscriptionOrderDirection
 ): SortFn {
 	if (orderBy === 'client') {
 		return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
 	}
 
-	switch (eventType) {
-		case 'OrderActionRecord':
-			return orderActionRecordSortFn;
-		default:
-			return defaultBlockchainSortFn;
-	}
+	return blockchainSortFn;
 }

package/src/examples/loadDlob.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider } from '@coral-xyz/anchor';
-import { DLOB, UserMap, Wallet } from '..';
+import { UserMap, Wallet } from '..';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
 	DriftClient,
@@ -55,17 +55,22 @@ const main = async () => {
 	await driftClient.subscribe();
 
 	console.log('Loading user map...');
-	const userMap = new UserMap(driftClient, {
-		type: 'polling',
-		accountLoader: bulkAccountLoader,
+	const userMap = new UserMap({
+		driftClient,
+		subscriptionConfig: {
+			type: 'websocket',
+			commitment: 'processed',
+		},
+		skipInitialLoad: false,
+		includeIdle: false,
 	});
 
 	// fetches all users and subscribes for updates
 	await userMap.subscribe();
 
 	console.log('Loading dlob from user map...');
-	const dlob = new DLOB();
-	await dlob.initFromUserMap(userMap, bulkAccountLoader.mostRecentSlot);
+	const slot = await driftClient.connection.getSlot();
+	const dlob = await userMap.getDLOB(slot);
 
 	console.log('number of orders', dlob.getDLOBOrders().length);
 

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './types';
 export * from './constants/perpMarkets';
 export * from './accounts/fetch';
 export * from './accounts/webSocketDriftClientAccountSubscriber';
+export * from './accounts/webSocketInsuranceFundStakeAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
 export * from './accounts/bulkUserStatsSubscription';
@@ -18,7 +19,8 @@ export * from './accounts/pollingOracleAccountSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/pollingUserAccountSubscriber';
 export * from './accounts/pollingUserStatsAccountSubscriber';
-export * from './accounts/mockUserAccountSubscriber';
+export * from './accounts/pollingInsuranceFundStakeAccountSubscriber';
+export * from './accounts/basicUserAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './adminClient';

package/src/math/auction.ts

@@ -26,7 +26,14 @@ export function getAuctionPrice(
 	slot: number,
 	oraclePrice: BN
 ): BN {
-	if (isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'limit'])) {
+	if (
+		isOneOfVariant(order.orderType, [
+			'market',
+			'triggerMarket',
+			'limit',
+			'triggerLimit',
+		])
+	) {
 		return getAuctionPriceForFixedAuction(order, slot);
 	} else if (isVariant(order.orderType, 'oracle')) {
 		return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);

package/src/orderSubscriber/OrderSubscriber.ts

@@ -94,12 +94,16 @@ export class OrderSubscriber {
 					programAccount.account.data,
 					slot
 				);
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 
 			for (const key of this.usersAccounts.keys()) {
 				if (!programAccountSet.has(key)) {
 					this.usersAccounts.delete(key);
 				}
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 		} catch (e) {
 			console.error(e);

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -10,7 +10,7 @@ export class WebsocketSubscription {
 	private skipInitialLoad: boolean;
 	private resubTimeoutMs?: number;
 
-	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+	private subscriber?: WebSocketProgramAccountSubscriber<UserAccount>;
 
 	constructor({
 		orderSubscriber,
@@ -30,22 +30,24 @@ export class WebsocketSubscription {
 	}
 
 	public async subscribe(): Promise<void> {
-		if (!this.subscriber) {
-			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
-				'OrderSubscriber',
-				'User',
-				this.orderSubscriber.driftClient.program,
-				this.orderSubscriber.driftClient.program.account.user.coder.accounts.decode.bind(
-					this.orderSubscriber.driftClient.program.account.user.coder.accounts
-				),
-				{
-					filters: [getUserFilter(), getNonIdleUserFilter()],
-					commitment: this.commitment,
-				},
-				this.resubTimeoutMs
-			);
+		if (this.subscriber) {
+			return;
 		}
 
+		this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+			'OrderSubscriber',
+			'User',
+			this.orderSubscriber.driftClient.program,
+			this.orderSubscriber.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+				this.orderSubscriber.driftClient.program.account.user.coder.accounts
+			),
+			{
+				filters: [getUserFilter(), getNonIdleUserFilter()],
+				commitment: this.commitment,
+			},
+			this.resubTimeoutMs
+		);
+
 		await this.subscriber.subscribe(
 			(accountId: PublicKey, account: UserAccount, context: Context) => {
 				const userKey = accountId.toBase58();
@@ -65,6 +67,7 @@ export class WebsocketSubscription {
 
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscriber) return;
-		this.subscriber.unsubscribe();
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
 	}
 }

package/src/types.ts

@@ -1000,8 +1000,6 @@ export interface IVersionedWallet {
 
 export type FeeStructure = {
 	feeTiers: FeeTier[];
-	makerRebateNumerator: BN;
-	makerRebateDenominator: BN;
 	fillerRewardStructure: OrderFillerRewardStructure;
 	flatFillerFee: BN;
 	referrerRewardEpochUpperBound: BN;

package/src/userMap/PollingSubscription.ts

@@ -0,0 +1,46 @@
+import { UserMap } from './userMap';
+
+export class PollingSubscription {
+	private userMap: UserMap;
+	private frequency: number;
+	private skipInitialLoad: boolean;
+
+	intervalId?: ReturnType<typeof setTimeout>;
+
+	constructor({
+		userMap,
+		frequency,
+		skipInitialLoad = false,
+	}: {
+		userMap: UserMap;
+		frequency: number;
+		skipInitialLoad?: boolean;
+		includeIdle?: boolean;
+	}) {
+		this.userMap = userMap;
+		this.frequency = frequency;
+		this.skipInitialLoad = skipInitialLoad;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		this.intervalId = setInterval(
+			this.userMap.sync.bind(this.userMap),
+			this.frequency
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.userMap.sync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/userMap/WebsocketSubscription.ts

@@ -0,0 +1,74 @@
+import { UserMap } from './userMap';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+
+export class WebsocketSubscription {
+	private userMap: UserMap;
+	private commitment: Commitment;
+	private skipInitialLoad: boolean;
+	private resubTimeoutMs?: number;
+	private includeIdle?: boolean;
+
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+
+	constructor({
+		userMap,
+		commitment,
+		skipInitialLoad = false,
+		resubTimeoutMs,
+		includeIdle = false,
+	}: {
+		userMap: UserMap;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubTimeoutMs?: number;
+		includeIdle?: boolean;
+	}) {
+		this.userMap = userMap;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.includeIdle = includeIdle || false;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (!this.subscriber) {
+			const filters = [getUserFilter()];
+			if (!this.includeIdle) {
+				filters.push(getNonIdleUserFilter());
+			}
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'UserMap',
+				'User',
+				this.userMap.driftClient.program,
+				this.userMap.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.userMap.driftClient.program.account.user.coder.accounts
+				),
+				{
+					filters,
+					commitment: this.commitment,
+				},
+				this.resubTimeoutMs
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, account: UserAccount, context: Context) => {
+				const userKey = accountId.toBase58();
+				this.userMap.updateUserAccount(userKey, account, context.slot);
+			}
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.userMap.sync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+	}
+}

package/src/userMap/userMap.ts

@@ -3,7 +3,6 @@ import {
 	DriftClient,
 	UserAccount,
 	OrderRecord,
-	UserSubscriptionConfig,
 	WrappedEvent,
 	DepositRecord,
 	FundingPaymentRecord,
@@ -14,11 +13,24 @@ import {
 	LPRecord,
 	StateAccount,
 	DLOB,
+	BasicUserAccountSubscriber,
+	BN,
 } from '..';
 
-import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import {
+	Commitment,
+	Connection,
+	PublicKey,
+	RpcResponseAndContext,
+} from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import {
+	UserAccountFilterCriteria as UserFilterCriteria,
+	UserMapConfig,
+} from './userMapConfig';
+import { WebsocketSubscription } from './WebsocketSubscription';
+import { PollingSubscription } from './PollingSubscription';
 
 export interface UserMapInterface {
 	subscribe(): Promise<void>;
@@ -32,59 +44,51 @@ export interface UserMapInterface {
 	values(): IterableIterator<User>;
 }
 
-// filter users that meet these criteria when passing into syncCallback
-export type SyncCallbackCriteria = {
-	// only sync users that have open orders
-	hasOpenOrders: boolean;
-};
-
 export class UserMap implements UserMapInterface {
 	private userMap = new Map<string, User>();
-	private driftClient: DriftClient;
-	private accountSubscription: UserSubscriptionConfig;
+	driftClient: DriftClient;
+	private connection: Connection;
+	private commitment: Commitment;
 	private includeIdle: boolean;
-	private lastNumberOfSubAccounts;
+	private lastNumberOfSubAccounts: BN;
+	private subscription: PollingSubscription | WebsocketSubscription;
 	private stateAccountUpdateCallback = async (state: StateAccount) => {
-		if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
+		if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
 			await this.sync();
 			this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
 		}
 	};
-	private syncCallback: (authorities: PublicKey[]) => Promise<void>;
-	private syncCallbackCriteria: SyncCallbackCriteria;
 
 	private syncPromise?: Promise<void>;
 	private syncPromiseResolver: () => void;
 
 	/**
 	 * Constructs a new UserMap instance.
-	 *
-	 * @param {DriftClient} driftClient - The DriftClient instance.
-	 * @param {UserSubscriptionConfig} accountSubscription - The UserSubscriptionConfig instance.
-	 * @param {boolean} includeIdle - Whether idle users are subscribed to. Defaults to false to decrease # of user subscriptions.
-	 * @param {(authorities: PublicKey[]) => Promise<void>} syncCallback - Called after `sync` completes, will pas in unique list of authorities. Useful for using it to sync UserStatsMap.
-	 * @param {SyncCallbackCriteria} syncCallbackCriteria - The criteria for the sync callback. Defaults to having no filters
 	 */
-	constructor(
-		driftClient: DriftClient,
-		accountSubscription: UserSubscriptionConfig,
-		includeIdle = false,
-		syncCallback?: (authorities: PublicKey[]) => Promise<void>,
-		syncCallbackCriteria: SyncCallbackCriteria = { hasOpenOrders: false }
-	) {
-		this.driftClient = driftClient;
-		this.accountSubscription = accountSubscription;
-		this.includeIdle = includeIdle;
-		this.syncCallback = syncCallback;
-		this.syncCallbackCriteria = syncCallbackCriteria;
-	}
-
-	public addSyncCallback(
-		syncCallback?: (authorities: PublicKey[]) => Promise<void>,
-		syncCallbackCriteria: SyncCallbackCriteria = { hasOpenOrders: false }
-	) {
-		this.syncCallback = syncCallback;
-		this.syncCallbackCriteria = syncCallbackCriteria;
+	constructor(config: UserMapConfig) {
+		this.driftClient = config.driftClient;
+		if (config.connection) {
+			this.connection = config.connection;
+		} else {
+			this.connection = this.driftClient.connection;
+		}
+		this.commitment =
+			config.subscriptionConfig.commitment ?? this.driftClient.opts.commitment;
+		this.includeIdle = config.includeIdle ?? false;
+		if (config.subscriptionConfig.type === 'polling') {
+			this.subscription = new PollingSubscription({
+				userMap: this,
+				frequency: config.subscriptionConfig.frequency,
+				skipInitialLoad: config.skipInitialLoad,
+			});
+		} else {
+			this.subscription = new WebsocketSubscription({
+				userMap: this,
+				commitment: this.commitment,
+				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+				skipInitialLoad: config.skipInitialLoad,
+			});
+		}
 	}
 
 	public async subscribe() {
@@ -100,17 +104,25 @@ export class UserMap implements UserMapInterface {
 			this.stateAccountUpdateCallback
 		);
 
-		await this.sync();
+		await this.subscription.subscribe();
 	}
 
 	public async addPubkey(
 		userAccountPublicKey: PublicKey,
-		userAccount?: UserAccount
+		userAccount?: UserAccount,
+		slot?: number
 	) {
 		const user = new User({
 			driftClient: this.driftClient,
 			userAccountPublicKey,
-			accountSubscription: this.accountSubscription,
+			accountSubscription: {
+				type: 'custom',
+				userAccountSubscriber: new BasicUserAccountSubscriber(
+					userAccountPublicKey,
+					userAccount,
+					slot
+				),
+			},
 		});
 		await user.subscribe(userAccount);
 		this.userMap.set(userAccountPublicKey.toString(), user);
@@ -216,14 +228,18 @@ export class UserMap implements UserMapInterface {
 		return this.userMap.size;
 	}
 
-	public getUniqueAuthorities(useSyncCallbackCriteria = true): PublicKey[] {
+	/**
+	 * Returns a unique list of authorities for all users in the UserMap that meet the filter criteria
+	 * @param filterCriteria: Users must meet these criteria to be included
+	 * @returns
+	 */
+	public getUniqueAuthorities(
+		filterCriteria?: UserFilterCriteria
+	): PublicKey[] {
 		const usersMeetingCriteria = Array.from(this.userMap.values()).filter(
 			(user) => {
 				let pass = true;
-				if (
-					useSyncCallbackCriteria &&
-					this.syncCallbackCriteria.hasOpenOrders
-				) {
+				if (filterCriteria && filterCriteria.hasOpenOrders) {
 					pass = pass && user.getUserAccount().hasOpenOrder;
 				}
 				return pass;
@@ -257,7 +273,7 @@ export class UserMap implements UserMapInterface {
 			const rpcRequestArgs = [
 				this.driftClient.program.programId.toBase58(),
 				{
-					commitment: this.driftClient.connection.commitment,
+					commitment: this.commitment,
 					filters,
 					encoding: 'base64',
 					withContext: true,
@@ -266,10 +282,7 @@ export class UserMap implements UserMapInterface {
 
 			const rpcJSONResponse: any =
 				// @ts-ignore
-				await this.driftClient.connection._rpcRequest(
-					'getProgramAccounts',
-					rpcRequestArgs
-				);
+				await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
 
 			const rpcResponseAndContext: RpcResponseAndContext<
 				Array<{
@@ -297,12 +310,14 @@ export class UserMap implements UserMapInterface {
 			for (const [key, buffer] of programAccountBufferMap.entries()) {
 				if (!this.has(key)) {
 					const userAccount =
-						this.driftClient.program.account.user.coder.accounts.decode(
+						this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
 							'User',
 							buffer
 						);
 					await this.addPubkey(new PublicKey(key), userAccount);
 				}
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 
 			for (const [key, user] of this.userMap.entries()) {
@@ -311,19 +326,17 @@ export class UserMap implements UserMapInterface {
 					this.userMap.delete(key);
 				} else {
 					const userAccount =
-						this.driftClient.program.account.user.coder.accounts.decode(
+						this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
 							'User',
 							programAccountBufferMap.get(key)
 						);
 					user.accountSubscriber.updateData(userAccount, slot);
 				}
-			}
-
-			if (this.syncCallback) {
-				await this.syncCallback(this.getUniqueAuthorities());
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 		} catch (e) {
-			console.error(`Error in UserMap.sync()`);
+			console.error(`Error in UserMap.sync():`);
 			console.error(e);
 		} finally {
 			this.syncPromiseResolver();
@@ -332,6 +345,8 @@ export class UserMap implements UserMapInterface {
 	}
 
 	public async unsubscribe() {
+		await this.subscription.unsubscribe();
+
 		for (const [key, user] of this.userMap.entries()) {
 			await user.unsubscribe();
 			this.userMap.delete(key);
@@ -345,4 +360,17 @@ export class UserMap implements UserMapInterface {
 			this.lastNumberOfSubAccounts = undefined;
 		}
 	}
+
+	public async updateUserAccount(
+		key: string,
+		userAccount: UserAccount,
+		slot: number
+	) {
+		if (!this.userMap.has(key)) {
+			this.addPubkey(new PublicKey(key), userAccount, slot);
+		} else {
+			const user = this.userMap.get(key);
+			user.accountSubscriber.updateData(userAccount, slot);
+		}
+	}
 }

package/src/userMap/userMapConfig.ts

@@ -0,0 +1,31 @@
+import { Commitment, Connection } from '@solana/web3.js';
+import { DriftClient } from '../driftClient';
+
+// passed into UserMap.getUniqueAuthorities to filter users
+export type UserAccountFilterCriteria = {
+	// only return users that have open orders
+	hasOpenOrders: boolean;
+};
+
+export type UserMapConfig = {
+	driftClient: DriftClient;
+	// connection object to use specifically for the UserMap. If undefined, will use the driftClient's connection
+	connection?: Connection;
+	subscriptionConfig:
+		| {
+				type: 'polling';
+				frequency: number;
+				commitment?: Commitment;
+		  }
+		| {
+				type: 'websocket';
+				resubTimeoutMs?: number;
+				commitment?: Commitment;
+		  };
+
+	// True to skip the initial load of userAccounts via getProgramAccounts
+	skipInitialLoad?: boolean;
+
+	// True to include idle users when loading. Defaults to false to decrease # of accounts subscribed to.
+	includeIdle?: boolean;
+};

package/tests/amm/test.ts

@@ -361,7 +361,10 @@ describe('AMM Tests', () => {
 
 		console.log(terms2);
 		assert(terms2.effectiveLeverageCapped <= 1.000001);
-		assert(terms2.inventorySpreadScale == 1.013527);
+		assert(
+			terms2.inventorySpreadScale == 1.013527,
+			`got: ${terms2.inventorySpreadScale}`
+		);
 		assert(terms2.longSpread == 1146);
 		assert(terms2.shortSpread == 6686);
 	});
@@ -466,7 +469,7 @@ describe('AMM Tests', () => {
 
 		assert(markTwapLive.eq(new BN('1949826')));
 		assert(oracleTwapLive.eq(new BN('1942510')));
-		assert(est1.eq(new BN('15692')));
+		assert(est1.eq(new BN('15692')), `got: ${est1}`);
 		assert(est2.eq(new BN('15692')));
 	});
 
@@ -556,7 +559,7 @@ describe('AMM Tests', () => {
 		assert(markTwapLive.eq(new BN('1222131')));
 		assert(oracleTwapLive.eq(new BN('1222586')));
 		assert(est1.eq(est2));
-		assert(est2.eq(new BN('-1550')));
+		assert(est2.eq(new BN('-1550')), `got: ${est2}`);
 	});
 
 	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders, low liquidity)', async () => {