@drift-labs/sdk 2.0.13 → 2.0.15

package/src/dlob/DLOB.ts

@@ -21,10 +21,9 @@ import {
 	MarketTypeStr,
 	StateAccount,
 	isMarketOrder,
-	isLimitOrder,
-	getOptionalLimitPrice,
 	mustBeTriggered,
 	isTriggered,
+	getLimitPrice,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
@@ -60,8 +59,6 @@ export type NodeToTrigger = {
 	node: TriggerOrderNode;
 };
 
-type Side = 'ask' | 'bid' | 'both' | 'nocross';
-
 export class DLOB {
 	openOrders = new Map<MarketTypeStr, Set<string>>();
 	orderLists = new Map<MarketTypeStr, Map<number, MarketNodeLists>>();
@@ -302,25 +299,29 @@ export class DLOB {
 			return [];
 		}
 
-		// Find all the crossing nodes
-		const crossingNodesToFill: Array<NodeToFill> = this.findCrossingNodesToFill(
-			marketIndex,
-			slot,
-			marketType,
-			oraclePriceData
-		);
+		const isAmmPaused = ammPaused(this.stateAccount, marketAccount);
 
-		let fallbackCrossingNodesToFill = new Array<NodeToFill>();
-		if (!ammPaused(this.stateAccount, marketAccount)) {
-			fallbackCrossingNodesToFill = this.findFallbackCrossingNodesToFill(
+		const marketOrderNodesToFill: Array<NodeToFill> =
+			this.findMarketNodesToFill(
 				marketIndex,
-				fallbackBid,
+				slot,
+				marketType,
+				oraclePriceData,
+				isAmmPaused,
 				fallbackAsk,
+				fallbackBid
+			);
+
+		const limitOrderNodesToFill: Array<NodeToFill> =
+			this.findLimitOrderNodesToFill(
+				marketIndex,
 				slot,
 				marketType,
-				oraclePriceData
+				oraclePriceData,
+				isAmmPaused,
+				fallbackAsk,
+				fallbackBid
 			);
-		}
 
 		// get expired market nodes
 		const expiredNodesToFill = this.findExpiredNodesToFill(
@@ -328,160 +329,298 @@ export class DLOB {
 			ts,
 			marketType
 		);
-		return crossingNodesToFill.concat(
-			fallbackCrossingNodesToFill,
+		return marketOrderNodesToFill.concat(
+			limitOrderNodesToFill,
 			expiredNodesToFill
 		);
 	}
 
-	public findCrossingNodesToFill(
+	public findLimitOrderNodesToFill(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
-		oraclePriceData: OraclePriceData
+		oraclePriceData: OraclePriceData,
+		isAmmPaused: boolean,
+		fallbackAsk: BN | undefined,
+		fallbackBid: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
-		const askGenerator = this.getAsks(
+		const crossingNodes = this.findCrossingLimitOrders(
 			marketIndex,
-			undefined, // dont include vask
-			slot,
-			marketType,
-			oraclePriceData
-		);
-		const bidGenerator = this.getBids(
-			marketIndex,
-			undefined, // dont include vbid
 			slot,
 			marketType,
 			oraclePriceData
 		);
 
-		let nextAsk = askGenerator.next();
-		let nextBid = bidGenerator.next();
+		for (const crossingNode of crossingNodes) {
+			nodesToFill.push(crossingNode);
+		}
 
-		// First try to find orders that cross
-		while (!nextAsk.done && !nextBid.done) {
-			const { crossingNodes, exhaustedSide } = this.findCrossingOrders(
-				nextAsk.value,
-				nextBid.value,
+		if (fallbackBid && !isAmmPaused) {
+			const askGenerator = this.getLimitAsks(
+				marketIndex,
+				slot,
+				marketType,
+				oraclePriceData
+			);
+			const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(
+				marketType,
+				slot,
 				oraclePriceData,
-				slot
+				askGenerator,
+				fallbackBid,
+				(askPrice, fallbackPrice) => {
+					return askPrice.lte(fallbackPrice);
+				}
 			);
 
-			if (exhaustedSide === 'bid') {
-				nextBid = bidGenerator.next();
-			} else if (exhaustedSide === 'ask') {
-				nextAsk = askGenerator.next();
-			} else if (exhaustedSide === 'both') {
-				nextBid = bidGenerator.next();
-				nextAsk = askGenerator.next();
-			} else if (exhaustedSide === 'nocross') {
-				break;
-			} else {
-				console.error(`invalid exhaustedSide: ${exhaustedSide}`);
-				break;
+			for (const askCrossingFallback of asksCrossingFallback) {
+				nodesToFill.push(askCrossingFallback);
 			}
+		}
+
+		if (fallbackAsk && !isAmmPaused) {
+			const bidGenerator = this.getLimitBids(
+				marketIndex,
+				slot,
+				marketType,
+				oraclePriceData
+			);
+			const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(
+				marketType,
+				slot,
+				oraclePriceData,
+				bidGenerator,
+				fallbackAsk,
+				(bidPrice, fallbackPrice) => {
+					return bidPrice.gte(fallbackPrice);
+				}
+			);
 
-			for (const crossingNode of crossingNodes) {
-				nodesToFill.push(crossingNode);
+			for (const bidCrossingFallback of bidsCrossingFallback) {
+				nodesToFill.push(bidCrossingFallback);
 			}
 		}
+
 		return nodesToFill;
 	}
 
-	public findFallbackCrossingNodesToFill(
+	public findMarketNodesToFill(
 		marketIndex: number,
-		fallbackBid: BN,
-		fallbackAsk: BN,
 		slot: number,
 		marketType: MarketType,
-		oraclePriceData: OraclePriceData
+		oraclePriceData: OraclePriceData,
+		isAmmPaused: boolean,
+		fallbackAsk: BN | undefined,
+		fallbackBid?: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
-		const askGenerator = this.getAsks(
+		let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
+
+		const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(
 			marketIndex,
-			undefined, // dont include vask
 			slot,
 			marketType,
-			oraclePriceData
+			oraclePriceData,
+			marketOrderGenerator,
+			this.getLimitBids.bind(this),
+			(takerPrice, makerPrice) => {
+				return takerPrice === undefined || takerPrice.lte(makerPrice);
+			}
 		);
-		const bidGenerator = this.getBids(
+		for (const marketAskCrossingBid of marketAsksCrossingBids) {
+			nodesToFill.push(marketAskCrossingBid);
+		}
+
+		if (fallbackBid && !isAmmPaused) {
+			marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
+			const marketAsksCrossingFallback =
+				this.findNodesCrossingFallbackLiquidity(
+					marketType,
+					slot,
+					oraclePriceData,
+					marketOrderGenerator,
+					fallbackBid,
+					(takerPrice, fallbackPrice) => {
+						return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+					}
+				);
+
+			for (const marketAskCrossingFallback of marketAsksCrossingFallback) {
+				nodesToFill.push(marketAskCrossingFallback);
+			}
+		}
+
+		marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
+
+		const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(
 			marketIndex,
-			undefined, // dont include vbid
 			slot,
 			marketType,
-			oraclePriceData
+			oraclePriceData,
+			marketOrderGenerator,
+			this.getLimitAsks.bind(this),
+			(takerPrice, fallbackPrice) => {
+				return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+			}
 		);
 
-		let nextAsk = askGenerator.next();
-		let nextBid = bidGenerator.next();
-
-		// check for asks that cross fallbackBid
-		while (!nextAsk.done && fallbackBid !== undefined) {
-			const askNode = nextAsk.value;
+		for (const marketBidToFill of marketBidsToFill) {
+			nodesToFill.push(marketBidToFill);
+		}
 
-			if (isVariant(marketType, 'spot') && askNode.order?.postOnly) {
-				nextAsk = askGenerator.next();
-				continue;
+		if (fallbackAsk && !isAmmPaused) {
+			marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
+			const marketBidsCrossingFallback =
+				this.findNodesCrossingFallbackLiquidity(
+					marketType,
+					slot,
+					oraclePriceData,
+					marketOrderGenerator,
+					fallbackAsk,
+					(takerPrice, fallbackPrice) => {
+						return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+					}
+				);
+			for (const marketBidCrossingFallback of marketBidsCrossingFallback) {
+				nodesToFill.push(marketBidCrossingFallback);
 			}
+		}
 
-			const askLimitPrice = getOptionalLimitPrice(
-				askNode.order,
-				oraclePriceData,
-				slot
+		return nodesToFill;
+	}
+
+	public findMarketNodesCrossingLimitNodes(
+		marketIndex: number,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData,
+		takerNodeGenerator: Generator<DLOBNode>,
+		makerNodeGeneratorFn: (
+			marketIndex: number,
+			slot: number,
+			marketType: MarketType,
+			oraclePriceData: OraclePriceData
+		) => 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
 			);
 
-			// order crosses if there is no limit price or it crosses fallback price
-			const crosses =
-				askLimitPrice === undefined || askLimitPrice.lte(fallbackBid);
+			for (const makerNode of makerNodeGenerator) {
+				const bidUserAuthority = this.userMap.getUserAuthority(
+					makerNode.userAccount.toString()
+				);
+				const askUserAuthority = this.userMap.getUserAuthority(
+					takerNode.userAccount.toString()
+				);
 
-			// fallback is available if auction is complete or it's a spot order
-			const fallbackAvailable =
-				isVariant(marketType, 'spot') || isAuctionComplete(askNode.order, slot);
+				// Can't match orders from the same authority
+				const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+
+				if (sameAuthority) {
+					continue;
+				}
+
+				const makerPrice = makerNode.getPrice(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;
+				}
 
-			if (crosses && fallbackAvailable) {
 				nodesToFill.push({
-					node: askNode,
-					makerNode: undefined, // filled by fallback
+					node: takerNode,
+					makerNode: makerNode,
 				});
-			}
 
-			nextAsk = askGenerator.next();
+				const makerOrder = makerNode.order;
+				const takerOrder = takerNode.order;
+
+				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.getListForOrder(newMakerOrder).update(
+					newMakerOrder,
+					makerNode.userAccount
+				);
+
+				const newTakerOrder = { ...takerOrder };
+				newTakerOrder.baseAssetAmountFilled =
+					takerOrder.baseAssetAmountFilled.add(baseFilled);
+				this.getListForOrder(newTakerOrder).update(
+					newTakerOrder,
+					takerNode.userAccount
+				);
+
+				if (
+					newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)
+				) {
+					break;
+				}
+			}
 		}
 
-		// check for bids that cross fallbackAsk
-		while (!nextBid.done && fallbackAsk !== undefined) {
-			const bidNode = nextBid.value;
+		return nodesToFill;
+	}
+
+	public findNodesCrossingFallbackLiquidity(
+		marketType: MarketType,
+		slot: number,
+		oraclePriceData: OraclePriceData,
+		nodeGenerator: Generator<DLOBNode>,
+		fallbackPrice: BN,
+		doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean
+	): NodeToFill[] {
+		const nodesToFill = new Array<NodeToFill>();
+
+		let nextNode = nodeGenerator.next();
+		while (!nextNode.done) {
+			const node = nextNode.value;
 
-			if (isVariant(marketType, 'spot') && bidNode.order?.postOnly) {
-				nextBid = bidGenerator.next();
+			if (isVariant(marketType, 'spot') && node.order?.postOnly) {
+				nextNode = nodeGenerator.next();
 				continue;
 			}
 
-			const bidLimitPrice = getOptionalLimitPrice(
-				bidNode.order,
-				oraclePriceData,
-				slot
-			);
+			const nodePrice = getLimitPrice(node.order, oraclePriceData, slot);
 
 			// order crosses if there is no limit price or it crosses fallback price
-			const crosses =
-				bidLimitPrice === undefined || bidLimitPrice.gte(fallbackAsk);
+			const crosses = doesCross(nodePrice, fallbackPrice);
 
 			// fallback is available if auction is complete or it's a spot order
 			const fallbackAvailable =
-				isVariant(marketType, 'spot') || isAuctionComplete(bidNode.order, slot);
+				isVariant(marketType, 'spot') || isAuctionComplete(node.order, slot);
 
 			if (crosses && fallbackAvailable) {
 				nodesToFill.push({
-					node: bidNode,
+					node: node,
 					makerNode: undefined, // filled by fallback
 				});
 			}
 
-			nextBid = bidGenerator.next();
+			nextNode = nodeGenerator.next();
 		}
 
 		return nodesToFill;
@@ -557,64 +696,56 @@ export class DLOB {
 		return nodesToFill;
 	}
 
-	public getMarketBids(
+	*getMarketBids(
 		marketIndex: number,
 		marketType: MarketType
 	): Generator<DLOBNode> {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		return this.orderLists
+		const generator = this.orderLists
 			.get(marketTypeStr)
 			.get(marketIndex)
 			.market.bid.getGenerator();
+		for (const marketBidNode of generator) {
+			if (marketBidNode.isBaseFilled()) {
+				continue;
+			}
+			yield marketBidNode;
+		}
 	}
 
-	public getMarketAsks(
+	*getMarketAsks(
 		marketIndex: number,
 		marketType: MarketType
 	): Generator<DLOBNode> {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		return this.orderLists
+		const generator = this.orderLists
 			.get(marketTypeStr)
 			.get(marketIndex)
 			.market.ask.getGenerator();
+		for (const marketAskNode of generator) {
+			if (marketAskNode.isBaseFilled()) {
+				continue;
+			}
+			yield marketAskNode;
+		}
 	}
 
-	*getAsks(
-		marketIndex: number,
-		fallbackAsk: BN | undefined,
+	private *getBestNode(
+		generatorList: Array<Generator<DLOBNode>>,
+		oraclePriceData: OraclePriceData,
 		slot: number,
-		marketType: MarketType,
-		oraclePriceData: OraclePriceData
+		compareFcn: (bestPrice: BN, currentPrice: BN) => boolean
 	): Generator<DLOBNode> {
-		if (isVariant(marketType, 'spot') && !oraclePriceData) {
-			throw new Error('Must provide OraclePriceData to get spot asks');
-		}
-		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
-		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
-
-		const generatorList = [
-			nodeLists.limit.ask.getGenerator(),
-			nodeLists.floatingLimit.ask.getGenerator(),
-			nodeLists.market.ask.getGenerator(),
-		];
-
-		if (marketTypeStr === 'perp' && fallbackAsk) {
-			generatorList.push(getVammNodeGenerator(fallbackAsk));
-		}
-		if (generatorList.length === 0) {
-			throw new Error('No ask generators found');
-		}
-
-		const askGenerators = generatorList.map((generator) => {
+		const generators = generatorList.map((generator) => {
 			return {
 				next: generator.next(),
 				generator,
 			};
 		});
 
-		let asksExhausted = false;
-		while (!asksExhausted) {
-			const bestGenerator = askGenerators.reduce(
+		let sideExhausted = false;
+		while (!sideExhausted) {
+			const bestGenerator = generators.reduce(
 				(bestGenerator, currentGenerator) => {
 					if (currentGenerator.next.done) {
 						return bestGenerator;
@@ -624,16 +755,21 @@ export class DLOB {
 						return currentGenerator;
 					}
 
-					const bestAskPrice = bestGenerator.next.value.getPrice(
-						oraclePriceData,
-						slot
-					);
-					const currentAskPrice = currentGenerator.next.value.getPrice(
-						oraclePriceData,
-						slot
-					);
+					const bestValue = bestGenerator.next.value as DLOBNode;
+					const currentValue = currentGenerator.next.value as DLOBNode;
 
-					return bestAskPrice.lt(currentAskPrice)
+					// always return the market orders first
+					if (bestValue.order && isMarketOrder(bestValue.order)) {
+						return bestGenerator;
+					}
+					if (currentValue.order && isMarketOrder(currentValue.order)) {
+						return currentGenerator;
+					}
+
+					const bestPrice = bestValue.getPrice(oraclePriceData, slot);
+					const currentPrice = currentValue.getPrice(oraclePriceData, slot);
+
+					return compareFcn(bestPrice, currentPrice)
 						? bestGenerator
 						: currentGenerator;
 				}
@@ -660,14 +796,40 @@ export class DLOB {
 				yield bestGenerator.next.value;
 				bestGenerator.next = bestGenerator.generator.next();
 			} else {
-				asksExhausted = true;
+				sideExhausted = true;
 			}
 		}
 	}
 
-	*getBids(
+	*getLimitAsks(
+		marketIndex: number,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData
+	): Generator<DLOBNode> {
+		if (isVariant(marketType, 'spot') && !oraclePriceData) {
+			throw new Error('Must provide OraclePriceData to get spot asks');
+		}
+		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
+		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+
+		const generatorList = [
+			nodeLists.limit.ask.getGenerator(),
+			nodeLists.floatingLimit.ask.getGenerator(),
+		];
+
+		yield* this.getBestNode(
+			generatorList,
+			oraclePriceData,
+			slot,
+			(bestPrice, currentPrice) => {
+				return bestPrice.lt(currentPrice);
+			}
+		);
+	}
+
+	*getLimitBids(
 		marketIndex: number,
-		fallbackBid: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
@@ -682,255 +844,192 @@ export class DLOB {
 		const generatorList = [
 			nodeLists.limit.bid.getGenerator(),
 			nodeLists.floatingLimit.bid.getGenerator(),
-			nodeLists.market.bid.getGenerator(),
 		];
-		if (marketTypeStr === 'perp' && fallbackBid) {
-			generatorList.push(getVammNodeGenerator(fallbackBid));
-		}
-		if (generatorList.length === 0) {
-			throw new Error('No bid generators found');
-		}
-
-		const bidGenerators = generatorList.map((generator) => {
-			return {
-				next: generator.next(),
-				generator,
-			};
-		});
-
-		let bidsExhausted = false; // there will always be the fallbackBid
-		while (!bidsExhausted) {
-			const bestGenerator = bidGenerators.reduce(
-				(bestGenerator, currentGenerator) => {
-					if (currentGenerator.next.done) {
-						return bestGenerator;
-					}
-
-					if (bestGenerator.next.done) {
-						return currentGenerator;
-					}
 
-					const bestBidPrice = bestGenerator.next.value.getPrice(
-						oraclePriceData,
-						slot
-					);
-					const currentBidPrice = currentGenerator.next.value.getPrice(
-						oraclePriceData,
-						slot
-					);
+		yield* this.getBestNode(
+			generatorList,
+			oraclePriceData,
+			slot,
+			(bestPrice, currentPrice) => {
+				return bestPrice.gt(currentPrice);
+			}
+		);
+	}
 
-					return bestBidPrice.gt(currentBidPrice)
-						? bestGenerator
-						: currentGenerator;
-				}
-			);
+	*getAsks(
+		marketIndex: number,
+		fallbackAsk: BN | undefined,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData
+	): Generator<DLOBNode> {
+		if (isVariant(marketType, 'spot') && !oraclePriceData) {
+			throw new Error('Must provide OraclePriceData to get spot asks');
+		}
 
-			if (!bestGenerator.next.done) {
-				// skip this node if it's already completely filled
-				if (bestGenerator.next.value.isBaseFilled()) {
-					bestGenerator.next = bestGenerator.generator.next();
-					continue;
-				}
+		const generatorList = [
+			this.getMarketAsks(marketIndex, marketType),
+			this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData),
+		];
 
-				// skip order if user is being liquidated/bankrupt
-				if (bestGenerator.next.value.userAccount !== undefined) {
-					const user = this.userMap.get(
-						bestGenerator.next.value.userAccount.toString()
-					);
-					if (user?.isBeingLiquidated()) {
-						bestGenerator.next = bestGenerator.generator.next();
-						continue;
-					}
-				}
+		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
+		if (marketTypeStr === 'perp' && fallbackAsk) {
+			generatorList.push(getVammNodeGenerator(fallbackAsk));
+		}
 
-				yield bestGenerator.next.value;
-				bestGenerator.next = bestGenerator.generator.next();
-			} else {
-				bidsExhausted = true;
+		yield* this.getBestNode(
+			generatorList,
+			oraclePriceData,
+			slot,
+			(bestPrice, currentPrice) => {
+				return bestPrice.lt(currentPrice);
 			}
-		}
+		);
 	}
 
-	findCrossingOrders(
-		askNode: DLOBNode,
-		bidNode: DLOBNode,
-		oraclePriceData: OraclePriceData,
-		slot: number
-	): {
-		crossingNodes: NodeToFill[];
-		exhaustedSide: Side;
-	} {
-		const bidPrice = bidNode.getPrice(oraclePriceData, slot);
-		const askPrice = askNode.getPrice(oraclePriceData, slot);
-
-		// orders don't cross - we're done walkin gup the book
-		if (bidPrice.lt(askPrice)) {
-			return {
-				crossingNodes: [],
-				exhaustedSide: 'nocross',
-			};
+	*getBids(
+		marketIndex: number,
+		fallbackBid: BN | undefined,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData
+	): Generator<DLOBNode> {
+		if (isVariant(marketType, 'spot') && !oraclePriceData) {
+			throw new Error('Must provide OraclePriceData to get spot bids');
 		}
 
-		const bidOrder = bidNode.order;
-		const askOrder = askNode.order;
-
-		const bidUserAuthority = this.userMap.getUserAuthority(
-			bidNode.userAccount.toString()
-		);
-		const askUserAuthority = this.userMap.getUserAuthority(
-			askNode.userAccount.toString()
-		);
+		const generatorList = [
+			this.getMarketBids(marketIndex, marketType),
+			this.getLimitBids(marketIndex, slot, marketType, oraclePriceData),
+		];
 
-		// Can't match orders from the same authority
-		const sameAuthority = bidUserAuthority.equals(askUserAuthority);
-		if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
-			// don't have a principle way to pick which one to exhaust,
-			// exhaust each one 50% of the time so we can try each one against other orders
-			const exhaustedSide = Math.random() < 0.5 ? 'bid' : 'ask';
-			return {
-				crossingNodes: [],
-				exhaustedSide,
-			};
+		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
+		if (marketTypeStr === 'perp' && fallbackBid) {
+			generatorList.push(getVammNodeGenerator(fallbackBid));
 		}
 
-		const { takerNode, makerNode, makerSide } = this.determineMakerAndTaker(
-			askNode,
-			bidNode
+		yield* this.getBestNode(
+			generatorList,
+			oraclePriceData,
+			slot,
+			(bestPrice, currentPrice) => {
+				return bestPrice.gt(currentPrice);
+			}
 		);
+	}
 
-		// If maker is market order and auction is complete, cant be maker
-		if (
-			isMarketOrder(makerNode.order) &&
-			isAuctionComplete(makerNode.order, slot)
-		) {
-			return {
-				crossingNodes: [],
-				exhaustedSide: makerSide,
-			};
-		}
+	findCrossingLimitOrders(
+		marketIndex: number,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData
+	): NodeToFill[] {
+		const nodesToFill = new Array<NodeToFill>();
 
-		const bidBaseRemaining = bidOrder.baseAssetAmount.sub(
-			bidOrder.baseAssetAmountFilled
-		);
-		const askBaseRemaining = askOrder.baseAssetAmount.sub(
-			askOrder.baseAssetAmountFilled
-		);
+		for (const askNode of this.getLimitAsks(
+			marketIndex,
+			slot,
+			marketType,
+			oraclePriceData
+		)) {
+			for (const bidNode of this.getLimitBids(
+				marketIndex,
+				slot,
+				marketType,
+				oraclePriceData
+			)) {
+				const bidPrice = bidNode.getPrice(oraclePriceData, slot);
+				const askPrice = askNode.getPrice(oraclePriceData, slot);
 
-		let exhaustedSide: Side;
-		if (bidBaseRemaining.eq(askBaseRemaining)) {
-			exhaustedSide = 'both';
-		} else if (bidBaseRemaining.gt(askBaseRemaining)) {
-			exhaustedSide = 'ask';
-		} else {
-			exhaustedSide = 'bid';
-		}
+				// orders don't cross - we're done walking the book
+				if (bidPrice.lt(askPrice)) {
+					return nodesToFill;
+				}
 
-		// update the orders on DLOB as if they were fill - so we don't try to match them on the next iteration
-		// NOTE: if something goes wrong during the actual fill (transaction fails, i.e. due to orders already being filled)
-		// then we risk having a mismatch between this local DLOB and the actual DLOB state on the blockchain. This isn't
-		// a problem in the current implementation because we construct a new DLOB from the blockchain state every time, rather
-		// than updating the existing DLOB based on events.
-		if (exhaustedSide === 'ask') {
-			// bid partially filled
-			const newBidOrder = { ...bidOrder };
-			newBidOrder.baseAssetAmountFilled =
-				bidOrder.baseAssetAmountFilled.add(askBaseRemaining);
-			this.getListForOrder(newBidOrder).update(
-				newBidOrder,
-				bidNode.userAccount
-			);
+				const bidOrder = bidNode.order;
+				const askOrder = askNode.order;
 
-			// ask completely filled
-			const newAskOrder = { ...askOrder };
-			newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
-			this.getListForOrder(newAskOrder).update(
-				newAskOrder,
-				askNode.userAccount
-			);
-		} else if (exhaustedSide === 'bid') {
-			// ask partially filled
-			const newAskOrder = { ...askOrder };
-			newAskOrder.baseAssetAmountFilled =
-				askOrder.baseAssetAmountFilled.add(bidBaseRemaining);
-			this.getListForOrder(newAskOrder).update(
-				newAskOrder,
-				askNode.userAccount
-			);
+				const bidUserAuthority = this.userMap.getUserAuthority(
+					bidNode.userAccount.toString()
+				);
+				const askUserAuthority = this.userMap.getUserAuthority(
+					askNode.userAccount.toString()
+				);
 
-			// bid completely filled
-			const newBidOrder = { ...bidOrder };
-			newBidOrder.baseAssetAmountFilled = bidOrder.baseAssetAmount;
-			this.getListForOrder(newBidOrder).update(
-				newBidOrder,
-				bidNode.userAccount
-			);
-		} else {
-			// both completely filled
-			const newBidOrder = { ...bidOrder };
-			newBidOrder.baseAssetAmountFilled = bidOrder.baseAssetAmount;
-			this.getListForOrder(newBidOrder).update(
-				newBidOrder,
-				bidNode.userAccount
-			);
+				// Can't match orders from the same authority
+				const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+				if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
+					continue;
+				}
 
-			const newAskOrder = { ...askOrder };
-			newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
-			this.getListForOrder(newAskOrder).update(
-				newAskOrder,
-				askNode.userAccount
-			);
-		}
+				const { takerNode, makerNode } = this.determineMakerAndTaker(
+					askNode,
+					bidNode
+				);
+
+				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.getListForOrder(newBidOrder).update(
+					newBidOrder,
+					bidNode.userAccount
+				);
+
+				// ask completely filled
+				const newAskOrder = { ...askOrder };
+				newAskOrder.baseAssetAmountFilled =
+					askOrder.baseAssetAmountFilled.add(baseFilled);
+				this.getListForOrder(newAskOrder).update(
+					newAskOrder,
+					askNode.userAccount
+				);
 
-		return {
-			crossingNodes: [
-				{
+				nodesToFill.push({
 					node: takerNode,
 					makerNode: makerNode,
-				},
-			],
-			exhaustedSide,
-		};
+				});
+
+				if (newAskOrder.baseAssetAmount.eq(newAskOrder.baseAssetAmountFilled)) {
+					break;
+				}
+			}
+		}
+
+		return nodesToFill;
 	}
 
 	determineMakerAndTaker(
 		askNode: DLOBNode,
 		bidNode: DLOBNode
-	): { takerNode: DLOBNode; makerNode: DLOBNode; makerSide: Side } {
+	): { takerNode: DLOBNode; makerNode: DLOBNode } {
 		if (bidNode.order.postOnly) {
 			return {
 				takerNode: askNode,
 				makerNode: bidNode,
-				makerSide: 'bid',
 			};
 		} else if (askNode.order.postOnly) {
 			return {
 				takerNode: bidNode,
 				makerNode: askNode,
-				makerSide: 'ask',
-			};
-		} else if (isMarketOrder(bidNode.order) && isLimitOrder(askNode.order)) {
-			return {
-				takerNode: bidNode,
-				makerNode: askNode,
-				makerSide: 'ask',
-			};
-		} else if (isMarketOrder(askNode.order) && isLimitOrder(bidNode.order)) {
-			return {
-				takerNode: askNode,
-				makerNode: bidNode,
-				makerSide: 'bid',
 			};
 		} else if (askNode.order.slot.lt(bidNode.order.slot)) {
 			return {
 				takerNode: bidNode,
 				makerNode: askNode,
-				makerSide: 'ask',
 			};
 		} else {
 			return {
 				takerNode: askNode,
 				makerNode: bidNode,
-				makerSide: 'bid',
 			};
 		}
 	}