@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/dlob/DLOB.ts

@@ -1,2222 +0,0 @@
-/**
- * DLOB — Decentralized Limit Order Book.
- *
- * Maintains an in-memory order book built from on-chain `User` accounts.
- * Used by keeper bots to identify the best maker orders to match against taker fills.
- *
- * Key types:
- *   {@link DLOBNode}        — a single order node with price/size/user info (DLOBNode.ts)
- *   {@link DLOBSubscriber}  — subscribes to on-chain accounts and keeps the DLOB live (DLOBSubscriber.ts)
- *   {@link NodeList}        — sorted linked list of DLOBNodes per side/market (NodeList.ts)
- *   `orderBookLevels.ts`    — aggregated L2/L3 book level construction for quoting
- */
-import { getOrderSignature, NodeList } from './NodeList';
-import { BN } from '../isomorphic/anchor';
-import {
-	BASE_PRECISION,
-	BN_MAX,
-	PRICE_PRECISION,
-	QUOTE_PRECISION,
-	ZERO,
-} from '../constants/numericConstants';
-import { decodeName } from '../userName';
-import { DLOBNode, DLOBNodeType, TriggerOrderNode } from './DLOBNode';
-import { VelocityClient } from '../velocityClient';
-import {
-	calculateOrderBaseAssetAmount,
-	getLimitPrice,
-	isOrderExpired,
-	isRestingLimitOrder,
-	isTriggered,
-	mustBeTriggered,
-} from '../math/orders';
-import {
-	getVariant,
-	isOneOfVariant,
-	isVariant,
-	MarketType,
-	MarketTypeStr,
-	Order,
-	PerpMarketAccount,
-	PositionDirection,
-	SpotMarketAccount,
-	StateAccount,
-} from '../types';
-import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
-import { SlotSubscriber } from '../slot/SlotSubscriber';
-import { UserMap } from '../userMap/userMap';
-import { PublicKey } from '@solana/web3.js';
-import { ammPaused, exchangePaused, fillPaused } from '../math/exchangeStatus';
-import {
-	createL2Levels,
-	getL2GeneratorFromDLOBNodes,
-	L2OrderBook,
-	L2OrderBookGenerator,
-	L3Level,
-	L3OrderBook,
-	mergeL2LevelGenerators,
-} from './orderBookLevels';
-import { isFallbackAvailableLiquiditySource } from '../math/auction';
-import { convertToNumber } from '../math/conversion';
-
-export type DLOBOrder = { user: PublicKey; order: Order };
-export type DLOBOrders = DLOBOrder[];
-
-export type MarketNodeLists = {
-	restingLimit: {
-		ask: NodeList<'restingLimit'>;
-		bid: NodeList<'restingLimit'>;
-	};
-	floatingLimit: {
-		ask: NodeList<'floatingLimit'>;
-		bid: NodeList<'floatingLimit'>;
-	};
-	takingLimit: {
-		ask: NodeList<'takingLimit'>;
-		bid: NodeList<'takingLimit'>;
-	};
-	market: {
-		ask: NodeList<'market'>;
-		bid: NodeList<'market'>;
-	};
-	trigger: {
-		above: NodeList<'trigger'>;
-		below: NodeList<'trigger'>;
-	};
-	signedMsg: {
-		ask: NodeList<'signedMsg'>;
-		bid: NodeList<'signedMsg'>;
-	};
-};
-
-type OrderBookCallback = () => void;
-
-/**
- *  Receives a DLOBNode and is expected to return true if the node should
- *  be taken into account when generating, or false otherwise.
- *
- * Currently used in functions that rely on getBestNode
- */
-export type DLOBFilterFcn = (node: DLOBNode) => boolean;
-
-export type NodeToFill = {
-	node: DLOBNode;
-	makerNodes: DLOBNode[];
-};
-
-export type NodeToTrigger = {
-	node: TriggerOrderNode;
-};
-
-const SUPPORTED_ORDER_TYPES = [
-	'market',
-	'limit',
-	'triggerMarket',
-	'triggerLimit',
-	'oracle',
-];
-
-function getOrderOrThrow(node: DLOBNode): Order {
-	if (!node.order) {
-		throw new Error('DLOBNode must have an order');
-	}
-	return node.order;
-}
-
-function getUserAccountOrThrow(node: DLOBNode): string {
-	if (node.userAccount === undefined) {
-		throw new Error('DLOBNode must have a userAccount');
-	}
-	return node.userAccount;
-}
-
-export class DLOB {
-	openOrders = new Map<MarketTypeStr, Set<string>>();
-	orderLists = new Map<MarketTypeStr, Map<number, MarketNodeLists>>();
-	maxSlotForRestingLimitOrders = 0;
-
-	initialized = false;
-
-	public constructor() {
-		this.init();
-	}
-
-	private init() {
-		this.openOrders.set('perp', new Set<string>());
-		this.openOrders.set('spot', new Set<string>());
-		this.orderLists.set('perp', new Map<number, MarketNodeLists>());
-		this.orderLists.set('spot', new Map<number, MarketNodeLists>());
-	}
-
-	private getOpenOrdersForMarketType(
-		marketTypeStr: MarketTypeStr
-	): Set<string> {
-		const openOrders = this.openOrders.get(marketTypeStr);
-		if (!openOrders) {
-			throw new Error(
-				`DLOB has no open orders set for market type ${marketTypeStr}`
-			);
-		}
-		return openOrders;
-	}
-
-	private getOrderListsForMarketType(
-		marketTypeStr: MarketTypeStr
-	): Map<number, MarketNodeLists> {
-		const orderLists = this.orderLists.get(marketTypeStr);
-		if (!orderLists) {
-			throw new Error(
-				`DLOB has no order lists for market type ${marketTypeStr}`
-			);
-		}
-		return orderLists;
-	}
-
-	private tryGetMarketNodeLists(
-		marketTypeStr: MarketTypeStr,
-		marketIndex: number
-	): MarketNodeLists | undefined {
-		return this.orderLists.get(marketTypeStr)?.get(marketIndex);
-	}
-
-	private getMarketNodeLists(
-		marketTypeStr: MarketTypeStr,
-		marketIndex: number
-	): MarketNodeLists {
-		const marketNodeLists = this.tryGetMarketNodeLists(
-			marketTypeStr,
-			marketIndex
-		);
-		if (!marketNodeLists) {
-			throw new Error(
-				`DLOB has no order lists for market type ${marketTypeStr} and market index ${marketIndex}`
-			);
-		}
-		return marketNodeLists;
-	}
-
-	public clear() {
-		for (const openOrders of this.openOrders.values()) {
-			openOrders.clear();
-		}
-		this.openOrders.clear();
-
-		for (const marketNodeListsMap of this.orderLists.values()) {
-			for (const marketNodeLists of marketNodeListsMap.values()) {
-				for (const side of Object.values(marketNodeLists)) {
-					for (const nodeList of Object.values(side)) {
-						nodeList.clear();
-					}
-				}
-			}
-		}
-		this.orderLists.clear();
-
-		this.maxSlotForRestingLimitOrders = 0;
-
-		this.init();
-	}
-
-	/**
-	 * initializes a new DLOB instance
-	 *
-	 * @returns a promise that resolves when the DLOB is initialized
-	 */
-	public async initFromUserMap(
-		userMap: UserMap,
-		slot: number
-	): Promise<boolean> {
-		if (this.initialized) {
-			return false;
-		}
-
-		// initialize the dlob with the user map
-		for (const user of userMap.values()) {
-			const userAccount = user.getUserAccountOrThrow();
-			const userAccountPubkey = user.getUserAccountPublicKey();
-			const userAccountPubkeyString = userAccountPubkey.toString();
-
-			for (const order of userAccount.orders) {
-				let baseAssetAmount = order.baseAssetAmount;
-				if (order.reduceOnly) {
-					const existingBaseAmount =
-						userAccount.perpPositions.find(
-							(pos) =>
-								pos.marketIndex === order.marketIndex && pos.openOrders > 0
-						)?.baseAssetAmount || ZERO;
-					baseAssetAmount = calculateOrderBaseAssetAmount(
-						order,
-						existingBaseAmount
-					);
-				}
-
-				this.insertOrder(order, userAccountPubkeyString, slot, baseAssetAmount);
-			}
-		}
-
-		this.initialized = true;
-		return true;
-	}
-
-	public insertOrder(
-		order: Order,
-		userAccount: string,
-		slot: number,
-		baseAssetAmount: BN,
-		onInsert?: OrderBookCallback
-	): void {
-		if (!isVariant(order.status, 'open')) {
-			return;
-		}
-
-		if (!isOneOfVariant(order.orderType, SUPPORTED_ORDER_TYPES)) {
-			return;
-		}
-
-		const marketType = getVariant(order.marketType) as MarketTypeStr;
-
-		if (!this.getOrderListsForMarketType(marketType).has(order.marketIndex)) {
-			this.addOrderList(marketType, order.marketIndex);
-		}
-
-		if (isVariant(order.status, 'open')) {
-			this.getOpenOrdersForMarketType(marketType).add(
-				getOrderSignature(order.orderId, userAccount)
-			);
-		}
-
-		this.getListForOnChainOrder(order, slot)?.insert(
-			order,
-			marketType,
-			userAccount,
-			baseAssetAmount
-		);
-
-		if (onInsert) {
-			onInsert();
-		}
-	}
-
-	public insertSignedMsgOrder(
-		order: Order,
-		userAccount: string,
-		baseAssetAmount?: BN,
-		onInsert?: OrderBookCallback
-	): void {
-		const marketType = getVariant(order.marketType) as MarketTypeStr;
-		const marketIndex = order.marketIndex;
-		const bidOrAsk = isVariant(order.direction, 'long') ? 'bid' : 'ask';
-		if (!this.getOrderListsForMarketType(marketType).has(order.marketIndex)) {
-			this.addOrderList(marketType, order.marketIndex);
-		}
-		this.getOpenOrdersForMarketType(marketType).add(
-			getOrderSignature(order.orderId, userAccount)
-		);
-		this.getMarketNodeLists(marketType, marketIndex).signedMsg[bidOrAsk].insert(
-			order,
-			marketType,
-			userAccount,
-			baseAssetAmount
-		);
-		if (onInsert) {
-			onInsert();
-		}
-	}
-
-	addOrderList(marketType: MarketTypeStr, marketIndex: number): void {
-		this.getOrderListsForMarketType(marketType).set(marketIndex, {
-			restingLimit: {
-				ask: new NodeList('restingLimit', 'asc'),
-				bid: new NodeList('restingLimit', 'desc'),
-			},
-			floatingLimit: {
-				ask: new NodeList('floatingLimit', 'asc'),
-				bid: new NodeList('floatingLimit', 'desc'),
-			},
-			takingLimit: {
-				ask: new NodeList('takingLimit', 'asc'),
-				bid: new NodeList('takingLimit', 'asc'), // always sort ascending for market orders
-			},
-			market: {
-				ask: new NodeList('market', 'asc'),
-				bid: new NodeList('market', 'asc'), // always sort ascending for market orders
-			},
-			trigger: {
-				above: new NodeList('trigger', 'asc'),
-				below: new NodeList('trigger', 'desc'),
-			},
-			signedMsg: {
-				ask: new NodeList('signedMsg', 'asc'),
-				bid: new NodeList('signedMsg', 'asc'),
-			},
-		});
-	}
-
-	public delete(
-		order: Order,
-		userAccount: PublicKey,
-		slot: number,
-		onDelete?: OrderBookCallback
-	): void {
-		if (!isVariant(order.status, 'open')) {
-			return;
-		}
-
-		this.updateRestingLimitOrders(slot);
-
-		this.getListForOnChainOrder(order, slot)?.remove(
-			order,
-			userAccount.toString()
-		);
-
-		if (onDelete) {
-			onDelete();
-		}
-	}
-
-	public getListForOnChainOrder(
-		order: Order,
-		slot: number
-	): NodeList<any> | undefined {
-		const isInactiveTriggerOrder =
-			mustBeTriggered(order) && !isTriggered(order);
-
-		const marketType = getVariant(order.marketType) as MarketTypeStr;
-
-		const marketNodeLists = this.tryGetMarketNodeLists(
-			marketType,
-			order.marketIndex
-		);
-		if (!marketNodeLists) {
-			return undefined;
-		}
-
-		if (isInactiveTriggerOrder) {
-			const subType = isVariant(order.triggerCondition, 'above')
-				? 'above'
-				: 'below';
-			return marketNodeLists.trigger[subType];
-		}
-
-		const subType = isVariant(order.direction, 'long') ? 'bid' : 'ask';
-		if (
-			isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle'])
-		) {
-			return marketNodeLists.market[subType];
-		} else if (!order.oraclePriceOffset.eq(ZERO)) {
-			return marketNodeLists.floatingLimit[subType];
-		} else {
-			const isResting = isRestingLimitOrder(order, slot);
-			return isResting
-				? marketNodeLists.restingLimit[subType]
-				: marketNodeLists.takingLimit[subType];
-		}
-	}
-
-	private getListForOnChainOrderOrThrow(
-		order: Order,
-		slot: number
-	): NodeList<any> {
-		const list = this.getListForOnChainOrder(order, slot);
-		if (!list) {
-			throw new Error(
-				`No order list found for order ${order.orderId} in market ${order.marketIndex}`
-			);
-		}
-		return list;
-	}
-
-	public updateRestingLimitOrders(slot: number): void {
-		if (slot <= this.maxSlotForRestingLimitOrders) {
-			return;
-		}
-
-		this.maxSlotForRestingLimitOrders = slot;
-
-		this.updateRestingLimitOrdersForMarketType(slot, 'perp');
-
-		this.updateRestingLimitOrdersForMarketType(slot, 'spot');
-	}
-
-	updateRestingLimitOrdersForMarketType(
-		slot: number,
-		marketTypeStr: MarketTypeStr
-	): void {
-		for (const [_, nodeLists] of this.getOrderListsForMarketType(
-			marketTypeStr
-		)) {
-			const nodesToUpdate: Array<{ side: 'ask' | 'bid'; node: DLOBNode }> = [];
-			for (const node of nodeLists.takingLimit.ask.getGenerator()) {
-				if (!isRestingLimitOrder(getOrderOrThrow(node), slot)) {
-					continue;
-				}
-
-				nodesToUpdate.push({
-					side: 'ask',
-					node,
-				});
-			}
-
-			for (const node of nodeLists.takingLimit.bid.getGenerator()) {
-				if (!isRestingLimitOrder(getOrderOrThrow(node), slot)) {
-					continue;
-				}
-
-				nodesToUpdate.push({
-					side: 'bid',
-					node,
-				});
-			}
-
-			for (const nodeToUpdate of nodesToUpdate) {
-				const { side, node } = nodeToUpdate;
-				const order = getOrderOrThrow(node);
-				const userAccount = getUserAccountOrThrow(node);
-				nodeLists.takingLimit[side].remove(order, userAccount);
-				nodeLists.restingLimit[side].insert(order, marketTypeStr, userAccount);
-			}
-		}
-	}
-
-	public getOrder(orderId: number, userAccount: PublicKey): Order | undefined {
-		const orderSignature = getOrderSignature(orderId, userAccount.toString());
-		for (const nodeList of this.getNodeLists()) {
-			const node = nodeList.get(orderSignature);
-			if (node) {
-				return node.order;
-			}
-		}
-
-		return undefined;
-	}
-
-	public findNodesToFill<T extends MarketType>(
-		marketIndex: number,
-		fallbackBid: BN | undefined,
-		fallbackAsk: BN | undefined,
-		slot: number,
-		ts: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		stateAccount: StateAccount,
-		marketAccount: T extends { spot: unknown }
-			? SpotMarketAccount
-			: PerpMarketAccount
-	): NodeToFill[] {
-		if (fillPaused(stateAccount, marketAccount)) {
-			return [];
-		}
-
-		const isAmmPaused = ammPaused(stateAccount, marketAccount);
-
-		const { makerRebateNumerator, makerRebateDenominator } =
-			this.getMakerRebate(marketType, stateAccount, marketAccount);
-
-		const takingOrderNodesToFill: Array<NodeToFill> =
-			this.findTakingNodesToFill(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData,
-				isAmmPaused,
-				stateAccount,
-				marketAccount,
-				fallbackAsk,
-				fallbackBid
-			);
-
-		const restingLimitOrderNodesToFill: Array<NodeToFill> =
-			this.findRestingLimitOrderNodesToFill(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData,
-				isAmmPaused,
-				stateAccount,
-				marketAccount,
-				makerRebateNumerator,
-				makerRebateDenominator,
-				fallbackAsk,
-				fallbackBid
-			);
-
-		// get expired market nodes
-		const expiredNodesToFill = this.findExpiredNodesToFill(
-			marketIndex,
-			ts,
-			marketType,
-			new BN(slot)
-		);
-
-		const stepSize = isVariant(marketType, 'perp')
-			? (marketAccount as PerpMarketAccount).orderStepSize
-			: (marketAccount as SpotMarketAccount).orderStepSize;
-
-		const cancelReduceOnlyNodesToFill =
-			this.findUnfillableReduceOnlyOrdersToCancel(
-				marketIndex,
-				marketType,
-				stepSize
-			);
-
-		return this.mergeNodesToFill(
-			restingLimitOrderNodesToFill,
-			takingOrderNodesToFill
-		)
-			.concat(expiredNodesToFill)
-			.concat(cancelReduceOnlyNodesToFill);
-	}
-
-	getMakerRebate(
-		marketType: MarketType,
-		stateAccount: StateAccount,
-		marketAccount: PerpMarketAccount | SpotMarketAccount
-	): { makerRebateNumerator: number; makerRebateDenominator: number } {
-		let makerRebateNumerator: number;
-		let makerRebateDenominator: number;
-		if (isVariant(marketType, 'perp')) {
-			makerRebateNumerator =
-				stateAccount.perpFeeStructure.feeTiers[0].makerRebateNumerator;
-			makerRebateDenominator =
-				stateAccount.perpFeeStructure.feeTiers[0].makerRebateDenominator;
-		} else {
-			makerRebateNumerator =
-				stateAccount.spotFeeStructure.feeTiers[0].makerRebateNumerator;
-			makerRebateDenominator =
-				stateAccount.spotFeeStructure.feeTiers[0].makerRebateDenominator;
-		}
-
-		// @ts-ignore
-		const feeAdjustment = marketAccount.feeAdjustment || 0;
-		if (feeAdjustment !== 0) {
-			makerRebateNumerator += (makerRebateNumerator * feeAdjustment) / 100;
-		}
-
-		return { makerRebateNumerator, makerRebateDenominator };
-	}
-
-	mergeNodesToFill(
-		restingLimitOrderNodesToFill: NodeToFill[],
-		takingOrderNodesToFill: NodeToFill[]
-	): NodeToFill[] {
-		const mergedNodesToFill = new Map<string, NodeToFill>();
-
-		const mergeNodesToFillHelper = (nodesToFillArray: NodeToFill[]) => {
-			nodesToFillArray.forEach((nodeToFill) => {
-				const nodeSignature = getOrderSignature(
-					getOrderOrThrow(nodeToFill.node).orderId,
-					getUserAccountOrThrow(nodeToFill.node)
-				);
-
-				let mergedNodeToFill = mergedNodesToFill.get(nodeSignature);
-				if (!mergedNodeToFill) {
-					mergedNodeToFill = {
-						node: nodeToFill.node,
-						makerNodes: [],
-					};
-					mergedNodesToFill.set(nodeSignature, mergedNodeToFill);
-				}
-
-				if (nodeToFill.makerNodes) {
-					mergedNodeToFill.makerNodes.push(...nodeToFill.makerNodes);
-				}
-			});
-		};
-
-		mergeNodesToFillHelper(restingLimitOrderNodesToFill);
-		mergeNodesToFillHelper(takingOrderNodesToFill);
-
-		return Array.from(mergedNodesToFill.values());
-	}
-
-	public findRestingLimitOrderNodesToFill<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		isAmmPaused: boolean,
-		stateAccount: StateAccount,
-		marketAccount: T extends { spot: unknown }
-			? SpotMarketAccount
-			: PerpMarketAccount,
-		makerRebateNumerator: number,
-		makerRebateDenominator: number,
-		fallbackAsk: BN | undefined,
-		fallbackBid: BN | undefined
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		const crossingNodes = this.findCrossingRestingLimitOrders(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		);
-
-		for (const crossingNode of crossingNodes) {
-			nodesToFill.push(crossingNode);
-		}
-
-		if (fallbackBid && !isAmmPaused) {
-			const askGenerator = this.getRestingLimitAsks(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData
-			);
-
-			const fallbackBidWithBuffer = fallbackBid.sub(
-				fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator)
-			);
-
-			const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(
-				marketType,
-				slot,
-				oraclePriceData,
-				askGenerator,
-				(askPrice) => {
-					if (askPrice === undefined) {
-						throw new Error('Resting limit ask must have a limit price');
-					}
-					return askPrice.lte(fallbackBidWithBuffer);
-				},
-				stateAccount,
-				marketAccount
-			);
-
-			for (const askCrossingFallback of asksCrossingFallback) {
-				nodesToFill.push(askCrossingFallback);
-			}
-		}
-
-		if (fallbackAsk && !isAmmPaused) {
-			const bidGenerator = this.getRestingLimitBids(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData
-			);
-
-			const fallbackAskWithBuffer = fallbackAsk.add(
-				fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator)
-			);
-
-			const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(
-				marketType,
-				slot,
-				oraclePriceData,
-				bidGenerator,
-				(bidPrice) => {
-					if (bidPrice === undefined) {
-						throw new Error('Resting limit bid must have a limit price');
-					}
-					return bidPrice.gte(fallbackAskWithBuffer);
-				},
-				stateAccount,
-				marketAccount
-			);
-
-			for (const bidCrossingFallback of bidsCrossingFallback) {
-				nodesToFill.push(bidCrossingFallback);
-			}
-		}
-
-		return nodesToFill;
-	}
-
-	public findTakingNodesToFill<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		isAmmPaused: boolean,
-		state: StateAccount,
-		marketAccount: T extends { spot: unknown }
-			? SpotMarketAccount
-			: PerpMarketAccount,
-		fallbackAsk: BN | undefined,
-		fallbackBid?: BN | undefined
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		let takingOrderGenerator = this.getTakingAsks(
-			marketIndex,
-			marketType,
-			slot,
-			oraclePriceData
-		);
-
-		const takingAsksCrossingBids = this.findTakingNodesCrossingMakerNodes(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData,
-			takingOrderGenerator,
-			this.getRestingLimitBids.bind(this),
-			(takerPrice, makerPrice) => {
-				if (isVariant(marketType, 'spot')) {
-					if (takerPrice === undefined) {
-						return false;
-					}
-
-					if (fallbackBid && makerPrice.lt(fallbackBid)) {
-						return false;
-					}
-				}
-				return takerPrice === undefined || takerPrice.lte(makerPrice);
-			}
-		);
-		for (const takingAskCrossingBid of takingAsksCrossingBids) {
-			nodesToFill.push(takingAskCrossingBid);
-		}
-
-		if (fallbackBid && !isAmmPaused) {
-			takingOrderGenerator = this.getTakingAsks(
-				marketIndex,
-				marketType,
-				slot,
-				oraclePriceData
-			);
-			const takingAsksCrossingFallback =
-				this.findNodesCrossingFallbackLiquidity(
-					marketType,
-					slot,
-					oraclePriceData,
-					takingOrderGenerator,
-					(takerPrice) => {
-						return takerPrice === undefined || takerPrice.lte(fallbackBid);
-					},
-					state,
-					marketAccount
-				);
-
-			for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
-				nodesToFill.push(takingAskCrossingFallback);
-			}
-		}
-
-		takingOrderGenerator = this.getTakingBids(
-			marketIndex,
-			marketType,
-			slot,
-			oraclePriceData
-		);
-
-		const takingBidsToFill = this.findTakingNodesCrossingMakerNodes(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData,
-			takingOrderGenerator,
-			this.getRestingLimitAsks.bind(this),
-			(takerPrice, makerPrice) => {
-				if (isVariant(marketType, 'spot')) {
-					if (takerPrice === undefined) {
-						return false;
-					}
-
-					if (fallbackAsk && makerPrice.gt(fallbackAsk)) {
-						return false;
-					}
-				}
-
-				return takerPrice === undefined || takerPrice.gte(makerPrice);
-			}
-		);
-
-		for (const takingBidToFill of takingBidsToFill) {
-			nodesToFill.push(takingBidToFill);
-		}
-
-		if (fallbackAsk && !isAmmPaused) {
-			takingOrderGenerator = this.getTakingBids(
-				marketIndex,
-				marketType,
-				slot,
-				oraclePriceData
-			);
-			const takingBidsCrossingFallback =
-				this.findNodesCrossingFallbackLiquidity(
-					marketType,
-					slot,
-					oraclePriceData,
-					takingOrderGenerator,
-					(takerPrice) => {
-						return takerPrice === undefined || takerPrice.gte(fallbackAsk);
-					},
-					state,
-					marketAccount
-				);
-			for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
-				nodesToFill.push(marketBidCrossingFallback);
-			}
-		}
-
-		return nodesToFill;
-	}
-
-	public findTakingNodesCrossingMakerNodes<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		takerNodeGenerator: Generator<DLOBNode>,
-		makerNodeGeneratorFn: (
-			marketIndex: number,
-			slot: number,
-			marketType: T,
-			oraclePriceData: T extends { spot: unknown }
-				? OraclePriceData
-				: MMOraclePriceData
-		) => Generator<DLOBNode>,
-		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		for (const takerNode of takerNodeGenerator) {
-			const makerNodeGenerator = makerNodeGeneratorFn(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData
-			);
-
-			for (const makerNode of makerNodeGenerator) {
-				// Can't match orders from the same user
-				const sameUser = takerNode.userAccount === makerNode.userAccount;
-				if (sameUser) {
-					continue;
-				}
-
-				const makerPrice = makerNode.getPriceOrThrow(oraclePriceData, slot);
-				const takerPrice = takerNode.getPrice(oraclePriceData, slot);
-
-				const ordersCross = doesCross(takerPrice, makerPrice);
-				if (!ordersCross) {
-					// market orders aren't sorted by price, they are sorted by time, so we need to traverse
-					// through all of em
-					break;
-				}
-
-				nodesToFill.push({
-					node: takerNode,
-					makerNodes: [makerNode],
-				});
-
-				const makerOrder = getOrderOrThrow(makerNode);
-				const takerOrder = getOrderOrThrow(takerNode);
-
-				const makerBaseRemaining = makerOrder.baseAssetAmount.sub(
-					makerOrder.baseAssetAmountFilled
-				);
-				const takerBaseRemaining = takerOrder.baseAssetAmount.sub(
-					takerOrder.baseAssetAmountFilled
-				);
-
-				const baseFilled = BN.min(makerBaseRemaining, takerBaseRemaining);
-
-				const newMakerOrder = { ...makerOrder };
-				newMakerOrder.baseAssetAmountFilled =
-					makerOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOnChainOrderOrThrow(newMakerOrder, slot).update(
-					newMakerOrder,
-					getUserAccountOrThrow(makerNode)
-				);
-
-				const newTakerOrder = { ...takerOrder };
-				newTakerOrder.baseAssetAmountFilled =
-					takerOrder.baseAssetAmountFilled.add(baseFilled);
-
-				if (takerNode.isSignedMsg) {
-					const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-					const marketNodeLists = this.getMarketNodeLists(
-						marketTypeStr,
-						marketIndex
-					);
-					const orderList = isVariant(takerOrder.direction, 'long')
-						? marketNodeLists.signedMsg.bid
-						: marketNodeLists.signedMsg.ask;
-					orderList.update(newTakerOrder, getUserAccountOrThrow(takerNode));
-				} else {
-					this.getListForOnChainOrderOrThrow(newTakerOrder, slot).update(
-						newTakerOrder,
-						getUserAccountOrThrow(takerNode)
-					);
-				}
-
-				if (
-					newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)
-				) {
-					break;
-				}
-			}
-		}
-
-		return nodesToFill;
-	}
-
-	public findNodesCrossingFallbackLiquidity<T extends MarketType>(
-		marketType: T,
-		slot: number,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		nodeGenerator: Generator<DLOBNode>,
-		doesCross: (nodePrice: BN | undefined) => boolean,
-		state: StateAccount,
-		marketAccount: T extends { spot: unknown }
-			? SpotMarketAccount
-			: PerpMarketAccount
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		let nextNode = nodeGenerator.next();
-		while (!nextNode.done) {
-			const node = nextNode.value;
-
-			if (isVariant(marketType, 'spot') && node.order?.postOnly) {
-				nextNode = nodeGenerator.next();
-				continue;
-			}
-			const nodeOrder = getOrderOrThrow(node);
-			const nodePrice = getLimitPrice(nodeOrder, oraclePriceData, slot);
-
-			// order crosses if there is no limit price or it crosses fallback price
-			const crosses = doesCross(nodePrice);
-
-			// fallback is available if auction is complete or it's a spot order
-			const fallbackAvailable =
-				isVariant(marketType, 'spot') ||
-				isFallbackAvailableLiquiditySource(
-					nodeOrder,
-					oraclePriceData as MMOraclePriceData,
-					slot,
-					state,
-					marketAccount as PerpMarketAccount
-				);
-
-			if (crosses && fallbackAvailable) {
-				nodesToFill.push({
-					node: node,
-					makerNodes: [], // filled by fallback
-				});
-			}
-
-			nextNode = nodeGenerator.next();
-		}
-
-		return nodesToFill;
-	}
-
-	public findExpiredNodesToFill(
-		marketIndex: number,
-		ts: number,
-		marketType: MarketType,
-		slot?: BN
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
-
-		if (!nodeLists) {
-			return nodesToFill;
-		}
-
-		// All bids/asks that can expire
-		// dont try to expire limit orders with tif as its inefficient use of blockspace
-		const bidGenerators = [
-			nodeLists.takingLimit.bid.getGenerator(),
-			nodeLists.restingLimit.bid.getGenerator(),
-			nodeLists.floatingLimit.bid.getGenerator(),
-			nodeLists.market.bid.getGenerator(),
-			nodeLists.signedMsg.bid.getGenerator(),
-		];
-		const askGenerators = [
-			nodeLists.takingLimit.ask.getGenerator(),
-			nodeLists.restingLimit.ask.getGenerator(),
-			nodeLists.floatingLimit.ask.getGenerator(),
-			nodeLists.market.ask.getGenerator(),
-			nodeLists.signedMsg.ask.getGenerator(),
-		];
-
-		for (const bidGenerator of bidGenerators) {
-			for (const bid of bidGenerator) {
-				const bidOrder = getOrderOrThrow(bid);
-				if (bid.isSignedMsg) {
-					if (slot === undefined) {
-						throw new Error(
-							'Must provide slot to findExpiredNodesToFill to expire signedMsg orders'
-						);
-					}
-					if (slot.gt(bidOrder.slot.addn(bidOrder.auctionDuration))) {
-						nodeLists.signedMsg.bid.remove(
-							bidOrder,
-							getUserAccountOrThrow(bid)
-						);
-						continue;
-					}
-				}
-				if (isOrderExpired(bidOrder, ts, true, 25)) {
-					nodesToFill.push({
-						node: bid,
-						makerNodes: [],
-					});
-				}
-			}
-		}
-
-		for (const askGenerator of askGenerators) {
-			for (const ask of askGenerator) {
-				const askOrder = getOrderOrThrow(ask);
-				if (ask.isSignedMsg) {
-					if (slot === undefined) {
-						throw new Error(
-							'Must provide slot to findExpiredNodesToFill to expire signedMsg orders'
-						);
-					}
-					if (slot.gt(askOrder.slot.addn(askOrder.auctionDuration))) {
-						nodeLists.signedMsg.ask.remove(
-							askOrder,
-							getUserAccountOrThrow(ask)
-						);
-						continue;
-					}
-				}
-				if (isOrderExpired(askOrder, ts, true, 25)) {
-					nodesToFill.push({
-						node: ask,
-						makerNodes: [],
-					});
-				}
-			}
-		}
-
-		return nodesToFill;
-	}
-
-	public findUnfillableReduceOnlyOrdersToCancel(
-		marketIndex: number,
-		marketType: MarketType,
-		stepSize: BN
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
-
-		if (!nodeLists) {
-			return nodesToFill;
-		}
-
-		const generators = [
-			nodeLists.takingLimit.bid.getGenerator(),
-			nodeLists.restingLimit.bid.getGenerator(),
-			nodeLists.floatingLimit.bid.getGenerator(),
-			nodeLists.market.bid.getGenerator(),
-			nodeLists.signedMsg.bid.getGenerator(),
-			nodeLists.takingLimit.ask.getGenerator(),
-			nodeLists.restingLimit.ask.getGenerator(),
-			nodeLists.floatingLimit.ask.getGenerator(),
-			nodeLists.market.ask.getGenerator(),
-			nodeLists.signedMsg.ask.getGenerator(),
-			nodeLists.trigger.above.getGenerator(),
-			nodeLists.trigger.below.getGenerator(),
-		];
-
-		for (const generator of generators) {
-			for (const node of generator) {
-				if (!getOrderOrThrow(node).reduceOnly) {
-					continue;
-				}
-
-				if (node.baseAssetAmount.lt(stepSize)) {
-					nodesToFill.push({
-						node,
-						makerNodes: [],
-					});
-				}
-			}
-		}
-
-		return nodesToFill;
-	}
-	*getTakingBids<T extends MarketType>(
-		marketIndex: number,
-		marketType: T,
-		slot: number,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const orderLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
-		if (!orderLists) {
-			return;
-		}
-
-		this.updateRestingLimitOrders(slot);
-
-		const generatorList = [
-			orderLists.market.bid.getGenerator(),
-			orderLists.takingLimit.bid.getGenerator(),
-			this.signedMsgGenerator(
-				orderLists.signedMsg.bid,
-				(x: DLOBNode) => !isRestingLimitOrder(getOrderOrThrow(x), slot)
-			),
-		];
-
-		yield* this.getBestNode(
-			generatorList,
-			oraclePriceData,
-			slot,
-			(bestNode, currentNode) => {
-				return getOrderOrThrow(bestNode).slot.lt(
-					getOrderOrThrow(currentNode).slot
-				);
-			},
-			filterFcn
-		);
-	}
-
-	*getTakingAsks<T extends MarketType>(
-		marketIndex: number,
-		marketType: T,
-		slot: number,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const orderLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
-		if (!orderLists) {
-			return;
-		}
-
-		this.updateRestingLimitOrders(slot);
-
-		const generatorList = [
-			orderLists.market.ask.getGenerator(),
-			orderLists.takingLimit.ask.getGenerator(),
-			this.signedMsgGenerator(
-				orderLists.signedMsg.ask,
-				(x: DLOBNode) => !isRestingLimitOrder(getOrderOrThrow(x), slot)
-			),
-		];
-
-		yield* this.getBestNode(
-			generatorList,
-			oraclePriceData,
-			slot,
-			(bestNode, currentNode) => {
-				return getOrderOrThrow(bestNode).slot.lt(
-					getOrderOrThrow(currentNode).slot
-				);
-			},
-			filterFcn
-		);
-	}
-
-	protected *signedMsgGenerator(
-		signedMsgOrderList: NodeList<'signedMsg'>,
-		filter: (x: DLOBNode) => boolean
-	): Generator<DLOBNode> {
-		for (const signedMsgOrder of signedMsgOrderList.getGenerator()) {
-			if (filter(signedMsgOrder)) {
-				yield signedMsgOrder;
-			}
-		}
-	}
-
-	protected *getBestNode<T extends MarketTypeStr>(
-		generatorList: Array<Generator<DLOBNode>>,
-		oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData,
-		slot: number,
-		compareFcn: (
-			bestDLOBNode: DLOBNode,
-			currentDLOBNode: DLOBNode,
-			slot: number,
-			oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData
-		) => boolean,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		const generators = generatorList.map((generator) => {
-			return {
-				next: generator.next(),
-				generator,
-			};
-		});
-
-		let sideExhausted = false;
-		while (!sideExhausted) {
-			const bestGenerator = generators.reduce(
-				(bestGenerator, currentGenerator) => {
-					if (currentGenerator.next.done) {
-						return bestGenerator;
-					}
-
-					if (bestGenerator.next.done) {
-						return currentGenerator;
-					}
-
-					const bestValue = bestGenerator.next.value as DLOBNode;
-					const currentValue = currentGenerator.next.value as DLOBNode;
-
-					return compareFcn(bestValue, currentValue, slot, oraclePriceData)
-						? bestGenerator
-						: currentGenerator;
-				}
-			);
-
-			if (!bestGenerator.next.done) {
-				// skip this node if it's already completely filled
-				if (bestGenerator.next.value.isBaseFilled()) {
-					bestGenerator.next = bestGenerator.generator.next();
-					continue;
-				}
-
-				if (filterFcn && !filterFcn(bestGenerator.next.value)) {
-					bestGenerator.next = bestGenerator.generator.next();
-					continue;
-				}
-
-				yield bestGenerator.next.value;
-				bestGenerator.next = bestGenerator.generator.next();
-			} else {
-				sideExhausted = true;
-			}
-		}
-	}
-
-	*getRestingLimitAsks<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		if (isVariant(marketType, 'spot') && !oraclePriceData) {
-			throw new Error('Must provide OraclePriceData to get spot asks');
-		}
-
-		this.updateRestingLimitOrders(slot);
-
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
-
-		if (!nodeLists) {
-			return;
-		}
-
-		const generatorList = [
-			nodeLists.restingLimit.ask.getGenerator(),
-			nodeLists.floatingLimit.ask.getGenerator(),
-			this.signedMsgGenerator(nodeLists.signedMsg.ask, (x: DLOBNode) =>
-				isRestingLimitOrder(getOrderOrThrow(x), slot)
-			),
-		];
-
-		yield* this.getBestNode(
-			generatorList,
-			oraclePriceData,
-			slot,
-			(bestNode, currentNode, slot, oraclePriceData) => {
-				return bestNode
-					.getPriceOrThrow(oraclePriceData, slot)
-					.lt(currentNode.getPriceOrThrow(oraclePriceData, slot));
-			},
-			filterFcn
-		);
-	}
-
-	*getRestingLimitBids<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		if (isVariant(marketType, 'spot') && !oraclePriceData) {
-			throw new Error('Must provide OraclePriceData to get spot bids');
-		}
-
-		this.updateRestingLimitOrders(slot);
-
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const nodeLists = this.tryGetMarketNodeLists(marketTypeStr, marketIndex);
-
-		if (!nodeLists) {
-			return;
-		}
-
-		const generatorList = [
-			nodeLists.restingLimit.bid.getGenerator(),
-			nodeLists.floatingLimit.bid.getGenerator(),
-			this.signedMsgGenerator(nodeLists.signedMsg.bid, (x: DLOBNode) =>
-				isRestingLimitOrder(getOrderOrThrow(x), slot)
-			),
-		];
-
-		yield* this.getBestNode(
-			generatorList,
-			oraclePriceData,
-			slot,
-			(bestNode, currentNode, slot, oraclePriceData) => {
-				return bestNode
-					.getPriceOrThrow(oraclePriceData, slot)
-					.gt(currentNode.getPriceOrThrow(oraclePriceData, slot));
-			},
-			filterFcn
-		);
-	}
-
-	/**
-	 * This will look at both the taking and resting limit asks
-	 * @param marketIndex
-	 * @param fallbackAsk
-	 * @param slot
-	 * @param marketType
-	 * @param oraclePriceData
-	 * @param filterFcn
-	 */
-	*getAsks<T extends MarketType>(
-		marketIndex: number,
-		_fallbackAsk: BN | undefined,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		if (isVariant(marketType, 'spot') && !oraclePriceData) {
-			throw new Error('Must provide OraclePriceData to get spot asks');
-		}
-
-		const generatorList = [
-			this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData),
-			this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData),
-		];
-
-		yield* this.getBestNode(
-			generatorList,
-			oraclePriceData,
-			slot,
-			(bestNode, currentNode, slot, oraclePriceData) => {
-				const bestNodePrice = bestNode.getPrice(oraclePriceData, slot) ?? ZERO;
-				const currentNodePrice =
-					currentNode.getPrice(oraclePriceData, slot) ?? ZERO;
-
-				if (bestNodePrice.eq(currentNodePrice)) {
-					return getOrderOrThrow(bestNode).slot.lt(
-						getOrderOrThrow(currentNode).slot
-					);
-				}
-
-				return bestNodePrice.lt(currentNodePrice);
-			},
-			filterFcn
-		);
-	}
-
-	/**
-	 * This will look at both the taking and resting limit bids
-	 * @param marketIndex
-	 * @param fallbackBid
-	 * @param slot
-	 * @param marketType
-	 * @param oraclePriceData
-	 * @param filterFcn
-	 */
-	*getBids<T extends MarketType>(
-		marketIndex: number,
-		_fallbackBid: BN | undefined,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData,
-		filterFcn?: DLOBFilterFcn
-	): Generator<DLOBNode> {
-		if (isVariant(marketType, 'spot') && !oraclePriceData) {
-			throw new Error('Must provide OraclePriceData to get spot bids');
-		}
-
-		const generatorList = [
-			this.getTakingBids(marketIndex, marketType, slot, oraclePriceData),
-			this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData),
-		];
-
-		yield* this.getBestNode(
-			generatorList,
-			oraclePriceData,
-			slot,
-			(bestNode, currentNode, slot, oraclePriceData) => {
-				const bestNodePrice =
-					bestNode.getPrice(oraclePriceData, slot) ?? BN_MAX;
-				const currentNodePrice =
-					currentNode.getPrice(oraclePriceData, slot) ?? BN_MAX;
-
-				if (bestNodePrice.eq(currentNodePrice)) {
-					return getOrderOrThrow(bestNode).slot.lt(
-						getOrderOrThrow(currentNode).slot
-					);
-				}
-
-				return bestNodePrice.gt(currentNodePrice);
-			},
-			filterFcn
-		);
-	}
-
-	findCrossingRestingLimitOrders<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData
-	): NodeToFill[] {
-		const nodesToFill = new Array<NodeToFill>();
-
-		for (const askNode of this.getRestingLimitAsks(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		)) {
-			const bidGenerator = this.getRestingLimitBids(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData
-			);
-
-			for (const bidNode of bidGenerator) {
-				const bidPrice = bidNode.getPriceOrThrow(oraclePriceData, slot);
-				const askPrice = askNode.getPriceOrThrow(oraclePriceData, slot);
-
-				// orders don't cross
-				if (bidPrice.lt(askPrice)) {
-					break;
-				}
-
-				const bidOrder = getOrderOrThrow(bidNode);
-				const askOrder = getOrderOrThrow(askNode);
-
-				// Can't match orders from the same user
-				const sameUser = bidNode.userAccount === askNode.userAccount;
-				if (sameUser) {
-					continue;
-				}
-
-				const makerAndTaker = this.determineMakerAndTaker(askNode, bidNode);
-
-				// unable to match maker and taker due to post only or slot
-				if (!makerAndTaker) {
-					continue;
-				}
-
-				const { takerNode, makerNode } = makerAndTaker;
-
-				const bidBaseRemaining = bidOrder.baseAssetAmount.sub(
-					bidOrder.baseAssetAmountFilled
-				);
-				const askBaseRemaining = askOrder.baseAssetAmount.sub(
-					askOrder.baseAssetAmountFilled
-				);
-
-				const baseFilled = BN.min(bidBaseRemaining, askBaseRemaining);
-
-				const newBidOrder = { ...bidOrder };
-				newBidOrder.baseAssetAmountFilled =
-					bidOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOnChainOrderOrThrow(newBidOrder, slot).update(
-					newBidOrder,
-					getUserAccountOrThrow(bidNode)
-				);
-
-				// ask completely filled
-				const newAskOrder = { ...askOrder };
-				newAskOrder.baseAssetAmountFilled =
-					askOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOnChainOrderOrThrow(newAskOrder, slot).update(
-					newAskOrder,
-					getUserAccountOrThrow(askNode)
-				);
-
-				nodesToFill.push({
-					node: takerNode,
-					makerNodes: [makerNode],
-				});
-
-				if (newAskOrder.baseAssetAmount.eq(newAskOrder.baseAssetAmountFilled)) {
-					break;
-				}
-			}
-		}
-
-		return nodesToFill;
-	}
-
-	determineMakerAndTaker(
-		askNode: DLOBNode,
-		bidNode: DLOBNode
-	): { takerNode: DLOBNode; makerNode: DLOBNode } | undefined {
-		const askOrder = getOrderOrThrow(askNode);
-		const bidOrder = getOrderOrThrow(bidNode);
-		const askSlot = askOrder.slot.add(new BN(askOrder.auctionDuration));
-		const bidSlot = bidOrder.slot.add(new BN(bidOrder.auctionDuration));
-
-		if (bidOrder.postOnly && askOrder.postOnly) {
-			return undefined;
-		} else if (bidOrder.postOnly) {
-			return {
-				takerNode: askNode,
-				makerNode: bidNode,
-			};
-		} else if (askOrder.postOnly) {
-			return {
-				takerNode: bidNode,
-				makerNode: askNode,
-			};
-		} else if (askSlot.lte(bidSlot)) {
-			return {
-				takerNode: bidNode,
-				makerNode: askNode,
-			};
-		} else {
-			return {
-				takerNode: askNode,
-				makerNode: bidNode,
-			};
-		}
-	}
-
-	public getBestAsk<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData
-	): BN | undefined {
-		const bestAsk = this.getRestingLimitAsks(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		).next().value;
-
-		if (bestAsk) {
-			return bestAsk.getPrice(oraclePriceData, slot);
-		}
-		return undefined;
-	}
-
-	public getBestBid<T extends MarketType>(
-		marketIndex: number,
-		slot: number,
-		marketType: T,
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData
-	): BN | undefined {
-		const bestBid = this.getRestingLimitBids(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		).next().value;
-
-		if (bestBid) {
-			return bestBid.getPrice(oraclePriceData, slot);
-		}
-		return undefined;
-	}
-
-	public *getStopLosses(
-		marketIndex: number,
-		marketType: MarketType,
-		direction: PositionDirection
-	): Generator<DLOBNode> {
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const marketNodeLists = this.getMarketNodeLists(marketTypeStr, marketIndex);
-
-		if (isVariant(direction, 'long') && marketNodeLists.trigger.below) {
-			for (const node of marketNodeLists.trigger.below.getGenerator()) {
-				if (isVariant(getOrderOrThrow(node).direction, 'short')) {
-					yield node;
-				}
-			}
-		} else if (isVariant(direction, 'short') && marketNodeLists.trigger.above) {
-			for (const node of marketNodeLists.trigger.above.getGenerator()) {
-				if (isVariant(getOrderOrThrow(node).direction, 'long')) {
-					yield node;
-				}
-			}
-		}
-	}
-
-	public *getStopLossMarkets(
-		marketIndex: number,
-		marketType: MarketType,
-		direction: PositionDirection
-	): Generator<DLOBNode> {
-		for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
-			if (isVariant(getOrderOrThrow(node).orderType, 'triggerMarket')) {
-				yield node;
-			}
-		}
-	}
-
-	public *getStopLossLimits(
-		marketIndex: number,
-		marketType: MarketType,
-		direction: PositionDirection
-	): Generator<DLOBNode> {
-		for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
-			if (isVariant(getOrderOrThrow(node).orderType, 'triggerLimit')) {
-				yield node;
-			}
-		}
-	}
-
-	public *getTakeProfits(
-		marketIndex: number,
-		marketType: MarketType,
-		direction: PositionDirection
-	): Generator<DLOBNode> {
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const marketNodeLists = this.getMarketNodeLists(marketTypeStr, marketIndex);
-
-		if (isVariant(direction, 'long') && marketNodeLists.trigger.above) {
-			for (const node of marketNodeLists.trigger.above.getGenerator()) {
-				if (isVariant(getOrderOrThrow(node).direction, 'short')) {
-					yield node;
-				}
-			}
-		} else if (isVariant(direction, 'short') && marketNodeLists.trigger.below) {
-			for (const node of marketNodeLists.trigger.below.getGenerator()) {
-				if (isVariant(getOrderOrThrow(node).direction, 'long')) {
-					yield node;
-				}
-			}
-		}
-	}
-
-	public *getTakeProfitMarkets(
-		marketIndex: number,
-		marketType: MarketType,
-		direction: PositionDirection
-	): Generator<DLOBNode> {
-		for (const node of this.getTakeProfits(
-			marketIndex,
-			marketType,
-			direction
-		)) {
-			if (isVariant(getOrderOrThrow(node).orderType, 'triggerMarket')) {
-				yield node;
-			}
-		}
-	}
-
-	public *getTakeProfitLimits(
-		marketIndex: number,
-		marketType: MarketType,
-		direction: PositionDirection
-	): Generator<DLOBNode> {
-		for (const node of this.getTakeProfits(
-			marketIndex,
-			marketType,
-			direction
-		)) {
-			if (isVariant(getOrderOrThrow(node).orderType, 'triggerLimit')) {
-				yield node;
-			}
-		}
-	}
-
-	public findNodesToTrigger(
-		marketIndex: number,
-		slot: number,
-		triggerPrice: BN,
-		marketType: MarketType,
-		stateAccount: StateAccount
-	): NodeToTrigger[] {
-		if (exchangePaused(stateAccount)) {
-			return [];
-		}
-
-		const nodesToTrigger: NodeToTrigger[] = [];
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const marketNodeLists = this.orderLists
-			.get(marketTypeStr)
-			?.get(marketIndex);
-
-		const triggerAboveList = marketNodeLists
-			? marketNodeLists.trigger.above
-			: undefined;
-		if (triggerAboveList) {
-			for (
-				let node = triggerAboveList.head;
-				node !== undefined;
-				node = node.next
-			) {
-				if (triggerPrice.gt(node.order.triggerPrice)) {
-					nodesToTrigger.push({
-						node: node,
-					});
-				} else {
-					break;
-				}
-			}
-		}
-
-		const triggerBelowList = marketNodeLists
-			? marketNodeLists.trigger.below
-			: undefined;
-		if (triggerBelowList) {
-			for (
-				let node = triggerBelowList.head;
-				node !== undefined;
-				node = node.next
-			) {
-				if (triggerPrice.lt(node.order.triggerPrice)) {
-					nodesToTrigger.push({
-						node: node,
-					});
-				} else {
-					break;
-				}
-			}
-		}
-
-		return nodesToTrigger;
-	}
-
-	public printTop(
-		velocityClient: VelocityClient,
-		slotSubscriber: SlotSubscriber,
-		marketIndex: number,
-		marketType: MarketType
-	) {
-		if (isVariant(marketType, 'perp')) {
-			const slot = slotSubscriber.getSlot();
-			const oraclePriceData =
-				velocityClient.getMMOracleDataForPerpMarket(marketIndex);
-
-			const bestAsk = this.getBestAsk(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData
-			);
-			const bestBid = this.getBestBid(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData
-			);
-			if (bestAsk === undefined || bestBid === undefined) {
-				throw new Error(
-					`printTop requires both a best ask and best bid for market ${marketIndex}`
-				);
-			}
-			const mid = bestAsk.add(bestBid).div(new BN(2));
-
-			const bidSpread =
-				(convertToNumber(bestBid, PRICE_PRECISION) /
-					convertToNumber(oraclePriceData.price, PRICE_PRECISION) -
-					1) *
-				100.0;
-			const askSpread =
-				(convertToNumber(bestAsk, PRICE_PRECISION) /
-					convertToNumber(oraclePriceData.price, PRICE_PRECISION) -
-					1) *
-				100.0;
-
-			const name = decodeName(
-				velocityClient.getPerpMarketAccountOrThrow(marketIndex).name
-			);
-			console.log(`Market ${name} Orders`);
-			console.log(
-				`  Ask`,
-				convertToNumber(bestAsk, PRICE_PRECISION).toFixed(3),
-				`(${askSpread.toFixed(4)}%)`
-			);
-			console.log(`  Mid`, convertToNumber(mid, PRICE_PRECISION).toFixed(3));
-			console.log(
-				`  Bid`,
-				convertToNumber(bestBid, PRICE_PRECISION).toFixed(3),
-				`(${bidSpread.toFixed(4)}%)`
-			);
-		} else if (isVariant(marketType, 'spot')) {
-			const slot = slotSubscriber.getSlot();
-			const oraclePriceData =
-				velocityClient.getOracleDataForSpotMarket(marketIndex);
-
-			const bestAsk = this.getBestAsk(
-				marketIndex,
-				slot,
-				MarketType.SPOT,
-				oraclePriceData
-			);
-			const bestBid = this.getBestBid(
-				marketIndex,
-				slot,
-				MarketType.SPOT,
-				oraclePriceData
-			);
-			if (bestAsk === undefined || bestBid === undefined) {
-				throw new Error(
-					`printTop requires both a best ask and best bid for market ${marketIndex}`
-				);
-			}
-			const mid = bestAsk.add(bestBid).div(new BN(2));
-
-			const bidSpread =
-				(convertToNumber(bestBid, PRICE_PRECISION) /
-					convertToNumber(oraclePriceData.price, PRICE_PRECISION) -
-					1) *
-				100.0;
-			const askSpread =
-				(convertToNumber(bestAsk, PRICE_PRECISION) /
-					convertToNumber(oraclePriceData.price, PRICE_PRECISION) -
-					1) *
-				100.0;
-
-			const name = decodeName(
-				velocityClient.getSpotMarketAccountOrThrow(marketIndex).name
-			);
-			console.log(`Market ${name} Orders`);
-			console.log(
-				`  Ask`,
-				convertToNumber(bestAsk, PRICE_PRECISION).toFixed(3),
-				`(${askSpread.toFixed(4)}%)`
-			);
-			console.log(`  Mid`, convertToNumber(mid, PRICE_PRECISION).toFixed(3));
-			console.log(
-				`  Bid`,
-				convertToNumber(bestBid, PRICE_PRECISION).toFixed(3),
-				`(${bidSpread.toFixed(4)}%)`
-			);
-		}
-	}
-
-	public getDLOBOrders(): DLOBOrders {
-		const dlobOrders: DLOBOrders = [];
-
-		for (const nodeList of this.getNodeLists()) {
-			for (const node of nodeList.getGenerator()) {
-				dlobOrders.push({
-					user: new PublicKey(getUserAccountOrThrow(node)),
-					order: getOrderOrThrow(node),
-				});
-			}
-		}
-
-		return dlobOrders;
-	}
-
-	*getNodeLists(): Generator<NodeList<DLOBNodeType>> {
-		for (const [_, nodeLists] of this.getOrderListsForMarketType('perp')) {
-			yield nodeLists.restingLimit.bid;
-			yield nodeLists.restingLimit.ask;
-			yield nodeLists.takingLimit.bid;
-			yield nodeLists.takingLimit.ask;
-			yield nodeLists.market.bid;
-			yield nodeLists.market.ask;
-			yield nodeLists.floatingLimit.bid;
-			yield nodeLists.floatingLimit.ask;
-			yield nodeLists.trigger.above;
-			yield nodeLists.trigger.below;
-		}
-
-		for (const [_, nodeLists] of this.getOrderListsForMarketType('spot')) {
-			yield nodeLists.restingLimit.bid;
-			yield nodeLists.restingLimit.ask;
-			yield nodeLists.takingLimit.bid;
-			yield nodeLists.takingLimit.ask;
-			yield nodeLists.market.bid;
-			yield nodeLists.market.ask;
-			yield nodeLists.floatingLimit.bid;
-			yield nodeLists.floatingLimit.ask;
-			yield nodeLists.trigger.above;
-			yield nodeLists.trigger.below;
-		}
-	}
-
-	/**
-	 * Get an L2 view of the order book for a given market.
-	 *
-	 * @param marketIndex
-	 * @param marketType
-	 * @param slot
-	 * @param oraclePriceData
-	 * @param depth how many levels of the order book to return
-	 * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}
-	 */
-	public getL2<T extends MarketType>({
-		marketIndex,
-		marketType,
-		slot,
-		oraclePriceData,
-		depth,
-		fallbackL2Generators = [],
-	}: {
-		marketIndex: number;
-		marketType: T;
-		slot: number;
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData;
-		depth: number;
-		fallbackL2Generators?: L2OrderBookGenerator[];
-	}): L2OrderBook {
-		const makerAskL2LevelGenerator = getL2GeneratorFromDLOBNodes(
-			this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData),
-			oraclePriceData,
-			slot
-		);
-
-		const fallbackAskGenerators = fallbackL2Generators.map(
-			(fallbackL2Generator) => {
-				return fallbackL2Generator.getL2Asks();
-			}
-		);
-
-		const askL2LevelGenerator = mergeL2LevelGenerators(
-			[makerAskL2LevelGenerator, ...fallbackAskGenerators],
-			(a, b) => {
-				return a.price.lt(b.price);
-			}
-		);
-
-		const asks = createL2Levels(askL2LevelGenerator, depth);
-
-		const makerBidGenerator = getL2GeneratorFromDLOBNodes(
-			this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData),
-			oraclePriceData,
-			slot
-		);
-
-		const fallbackBidGenerators = fallbackL2Generators.map((fallbackOrders) => {
-			return fallbackOrders.getL2Bids();
-		});
-
-		const bidL2LevelGenerator = mergeL2LevelGenerators(
-			[makerBidGenerator, ...fallbackBidGenerators],
-			(a, b) => {
-				return a.price.gt(b.price);
-			}
-		);
-
-		const bids = createL2Levels(bidL2LevelGenerator, depth);
-
-		return {
-			bids,
-			asks,
-			slot,
-		};
-	}
-
-	/**
-	 * Get an L3 view of the order book for a given market. Does not include fallback liquidity sources
-	 *
-	 * @param marketIndex
-	 * @param marketType
-	 * @param slot
-	 * @param oraclePriceData
-	 */
-	public getL3<T extends MarketType>({
-		marketIndex,
-		marketType,
-		slot,
-		oraclePriceData,
-	}: {
-		marketIndex: number;
-		marketType: T;
-		slot: number;
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData;
-	}): L3OrderBook {
-		const bids: L3Level[] = [];
-		const asks: L3Level[] = [];
-
-		const restingAsks = this.getRestingLimitAsks(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		);
-
-		for (const ask of restingAsks) {
-			const askOrder = getOrderOrThrow(ask);
-			asks.push({
-				price: ask.getPriceOrThrow(oraclePriceData, slot),
-				size: askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled),
-				maker: new PublicKey(getUserAccountOrThrow(ask)),
-				orderId: askOrder.orderId,
-			});
-		}
-
-		const restingBids = this.getRestingLimitBids(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		);
-
-		for (const bid of restingBids) {
-			const bidOrder = getOrderOrThrow(bid);
-			bids.push({
-				price: bid.getPriceOrThrow(oraclePriceData, slot),
-				size: bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled),
-				maker: new PublicKey(getUserAccountOrThrow(bid)),
-				orderId: bidOrder.orderId,
-			});
-		}
-
-		return {
-			bids,
-			asks,
-			slot,
-		};
-	}
-
-	private estimateFillExactBaseAmountInForSide(
-		baseAmountIn: BN,
-		oraclePriceData: OraclePriceData,
-		slot: number,
-		dlobSide: Generator<DLOBNode>
-	): BN {
-		let runningSumQuote = ZERO;
-		let runningSumBase = ZERO;
-		for (const side of dlobSide) {
-			const price = side.getPriceOrThrow(oraclePriceData, slot); //side.order.quoteAssetAmount.div(side.order.baseAssetAmount);
-			const sideOrder = getOrderOrThrow(side);
-			const baseAmountRemaining = sideOrder.baseAssetAmount.sub(
-				sideOrder.baseAssetAmountFilled
-			);
-			if (runningSumBase.add(baseAmountRemaining).gt(baseAmountIn)) {
-				const remainingBase = baseAmountIn.sub(runningSumBase);
-				runningSumBase = runningSumBase.add(remainingBase);
-				runningSumQuote = runningSumQuote.add(remainingBase.mul(price));
-				break;
-			} else {
-				runningSumBase = runningSumBase.add(baseAmountRemaining);
-				runningSumQuote = runningSumQuote.add(baseAmountRemaining.mul(price));
-			}
-		}
-
-		return runningSumQuote
-			.mul(QUOTE_PRECISION)
-			.div(BASE_PRECISION.mul(PRICE_PRECISION));
-	}
-
-	/**
-	 *
-	 * @param param.marketIndex the index of the market
-	 * @param param.marketType the type of the market
-	 * @param param.baseAmount the base amount in to estimate
-	 * @param param.orderDirection the direction of the trade
-	 * @param param.slot current slot for estimating dlob node price
-	 * @param param.oraclePriceData the oracle price data
-	 * @returns the estimated quote amount filled: QUOTE_PRECISION
-	 */
-	public estimateFillWithExactBaseAmount<T extends MarketType>({
-		marketIndex,
-		marketType,
-		baseAmount,
-		orderDirection,
-		slot,
-		oraclePriceData,
-	}: {
-		marketIndex: number;
-		marketType: T;
-		baseAmount: BN;
-		orderDirection: PositionDirection;
-		slot: number;
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData;
-	}): BN {
-		if (isVariant(orderDirection, 'long')) {
-			return this.estimateFillExactBaseAmountInForSide(
-				baseAmount,
-				oraclePriceData,
-				slot,
-				this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData)
-			);
-		} else if (isVariant(orderDirection, 'short')) {
-			return this.estimateFillExactBaseAmountInForSide(
-				baseAmount,
-				oraclePriceData,
-				slot,
-				this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData)
-			);
-		}
-		throw new Error(
-			`Invalid order direction ${getVariant(
-				orderDirection
-			)}: must be long or short`
-		);
-	}
-
-	public getBestMakers<T extends MarketType>({
-		marketIndex,
-		marketType,
-		direction,
-		slot,
-		oraclePriceData,
-		numMakers,
-	}: {
-		marketIndex: number;
-		marketType: T;
-		direction: PositionDirection;
-		slot: number;
-		oraclePriceData: T extends { spot: unknown }
-			? OraclePriceData
-			: MMOraclePriceData;
-		numMakers: number;
-	}): PublicKey[] {
-		const makers = new Map<string, PublicKey>();
-		const generator = isVariant(direction, 'long')
-			? this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData)
-			: this.getRestingLimitAsks(
-					marketIndex,
-					slot,
-					marketType,
-					oraclePriceData
-			  );
-
-		for (const node of generator) {
-			const userAccount = getUserAccountOrThrow(node);
-			if (!makers.has(userAccount)) {
-				makers.set(userAccount, new PublicKey(userAccount));
-			}
-
-			if (makers.size === numMakers) {
-				break;
-			}
-		}
-
-		return Array.from(makers.values());
-	}
-}