@drift-labs/sdk 2.17.0 → 2.18.0-beta.1

package/src/dlob/DLOB.ts

@@ -6,7 +6,6 @@ import {
 	calculateBidPrice,
 	DriftClient,
 	convertToNumber,
-	isAuctionComplete,
 	isOrderExpired,
 	isOneOfVariant,
 	isVariant,
@@ -19,7 +18,6 @@ import {
 	SlotSubscriber,
 	MarketTypeStr,
 	StateAccount,
-	isMarketOrder,
 	mustBeTriggered,
 	isTriggered,
 	getLimitPrice,
@@ -28,6 +26,9 @@ import {
 	OrderActionRecord,
 	ZERO,
 	BN_MAX,
+	isRestingLimitOrder,
+	isTakingOrder,
+	isFallbackAvailableLiquiditySource,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
@@ -35,14 +36,18 @@ import { ammPaused, exchangePaused, fillPaused } from '../math/exchangeStatus';
 import { DLOBOrders } from './DLOBOrders';
 
 export type MarketNodeLists = {
-	limit: {
-		ask: NodeList<'limit'>;
-		bid: NodeList<'limit'>;
+	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'>;
@@ -75,6 +80,7 @@ const SUPPORTED_ORDER_TYPES = [
 export class DLOB {
 	openOrders = new Map<MarketTypeStr, Set<string>>();
 	orderLists = new Map<MarketTypeStr, Map<number, MarketNodeLists>>();
+	maxSlotForRestingLimitOrders = 0;
 
 	initialized = false;
 
@@ -109,6 +115,8 @@ export class DLOB {
 		}
 		this.orderLists.clear();
 
+		this.maxSlotForRestingLimitOrders = 0;
+
 		this.init();
 	}
 
@@ -117,7 +125,10 @@ export class DLOB {
 	 *
 	 * @returns a promise that resolves when the DLOB is initialized
 	 */
-	public async initFromUserMap(userMap: UserMap): Promise<boolean> {
+	public async initFromUserMap(
+		userMap: UserMap,
+		slot: number
+	): Promise<boolean> {
 		if (this.initialized) {
 			return false;
 		}
@@ -128,7 +139,7 @@ export class DLOB {
 			const userAccountPubkey = user.getUserAccountPublicKey();
 
 			for (const order of userAccount.orders) {
-				this.insertOrder(order, userAccountPubkey);
+				this.insertOrder(order, userAccountPubkey, slot);
 			}
 		}
 
@@ -136,24 +147,27 @@ export class DLOB {
 		return true;
 	}
 
-	public initFromOrders(dlobOrders: DLOBOrders): boolean {
+	public initFromOrders(dlobOrders: DLOBOrders, slot: number): boolean {
 		if (this.initialized) {
 			return false;
 		}
 
 		for (const { user, order } of dlobOrders) {
-			this.insertOrder(order, user);
+			this.insertOrder(order, user, slot);
 		}
 
 		this.initialized = true;
 		return true;
 	}
 
-	public handleOrderRecord(record: OrderRecord): void {
-		this.insertOrder(record.order, record.user);
+	public handleOrderRecord(record: OrderRecord, slot: number): void {
+		this.insertOrder(record.order, record.user, slot);
 	}
 
-	public handleOrderActionRecord(record: OrderActionRecord): void {
+	public handleOrderActionRecord(
+		record: OrderActionRecord,
+		slot: number
+	): void {
 		if (isOneOfVariant(record.action, ['place', 'expire'])) {
 			return;
 		}
@@ -162,14 +176,14 @@ export class DLOB {
 			if (record.taker !== null) {
 				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
 				if (takerOrder) {
-					this.trigger(takerOrder, record.taker);
+					this.trigger(takerOrder, record.taker, slot);
 				}
 			}
 
 			if (record.maker !== null) {
 				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
 				if (makerOrder) {
-					this.trigger(makerOrder, record.maker);
+					this.trigger(makerOrder, record.maker, slot);
 				}
 			}
 		} else if (isVariant(record.action, 'fill')) {
@@ -179,6 +193,7 @@ export class DLOB {
 					this.updateOrder(
 						takerOrder,
 						record.taker,
+						slot,
 						record.takerOrderCumulativeBaseAssetAmountFilled
 					);
 				}
@@ -190,6 +205,7 @@ export class DLOB {
 					this.updateOrder(
 						makerOrder,
 						record.maker,
+						slot,
 						record.makerOrderCumulativeBaseAssetAmountFilled
 					);
 				}
@@ -198,14 +214,14 @@ export class DLOB {
 			if (record.taker !== null) {
 				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
 				if (takerOrder) {
-					this.delete(takerOrder, record.taker);
+					this.delete(takerOrder, record.taker, slot);
 				}
 			}
 
 			if (record.maker !== null) {
 				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
 				if (makerOrder) {
-					this.delete(makerOrder, record.maker);
+					this.delete(makerOrder, record.maker, slot);
 				}
 			}
 		}
@@ -214,6 +230,7 @@ export class DLOB {
 	public insertOrder(
 		order: Order,
 		userAccount: PublicKey,
+		slot: number,
 		onInsert?: OrderBookCallback
 	): void {
 		if (isVariant(order.status, 'init')) {
@@ -235,7 +252,7 @@ export class DLOB {
 				.get(marketType)
 				.add(getOrderSignature(order.orderId, userAccount));
 		}
-		this.getListForOrder(order)?.insert(order, marketType, userAccount);
+		this.getListForOrder(order, slot)?.insert(order, marketType, userAccount);
 
 		if (onInsert) {
 			onInsert();
@@ -244,14 +261,18 @@ export class DLOB {
 
 	addOrderList(marketType: MarketTypeStr, marketIndex: number): void {
 		this.orderLists.get(marketType).set(marketIndex, {
-			limit: {
-				ask: new NodeList('limit', 'asc'),
-				bid: new NodeList('limit', 'desc'),
+			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
@@ -266,11 +287,14 @@ export class DLOB {
 	public updateOrder(
 		order: Order,
 		userAccount: PublicKey,
+		slot: number,
 		cumulativeBaseAssetAmountFilled: BN,
 		onUpdate?: OrderBookCallback
 	): void {
+		this.updateRestingLimitOrders(slot);
+
 		if (order.baseAssetAmount.eq(cumulativeBaseAssetAmountFilled)) {
-			this.delete(order, userAccount);
+			this.delete(order, userAccount, slot);
 			return;
 		}
 
@@ -283,7 +307,7 @@ export class DLOB {
 		};
 		newOrder.baseAssetAmountFilled = cumulativeBaseAssetAmountFilled;
 
-		this.getListForOrder(order)?.update(newOrder, userAccount);
+		this.getListForOrder(order, slot)?.update(newOrder, userAccount);
 
 		if (onUpdate) {
 			onUpdate();
@@ -293,12 +317,15 @@ export class DLOB {
 	public trigger(
 		order: Order,
 		userAccount: PublicKey,
+		slot: number,
 		onTrigger?: OrderBookCallback
 	): void {
 		if (isVariant(order.status, 'init')) {
 			return;
 		}
 
+		this.updateRestingLimitOrders(slot);
+
 		if (isTriggered(order)) {
 			return;
 		}
@@ -309,7 +336,7 @@ export class DLOB {
 			.trigger[isVariant(order.triggerCondition, 'above') ? 'above' : 'below'];
 		triggerList.remove(order, userAccount);
 
-		this.getListForOrder(order)?.insert(order, marketType, userAccount);
+		this.getListForOrder(order, slot)?.insert(order, marketType, userAccount);
 		if (onTrigger) {
 			onTrigger();
 		}
@@ -318,19 +345,25 @@ export class DLOB {
 	public delete(
 		order: Order,
 		userAccount: PublicKey,
+		slot: number,
 		onDelete?: OrderBookCallback
 	): void {
 		if (isVariant(order.status, 'init')) {
 			return;
 		}
 
-		this.getListForOrder(order)?.remove(order, userAccount);
+		this.updateRestingLimitOrders(slot);
+
+		this.getListForOrder(order, slot)?.remove(order, userAccount);
 		if (onDelete) {
 			onDelete();
 		}
 	}
 
-	public getListForOrder(order: Order): NodeList<any> | undefined {
+	public getListForOrder(
+		order: Order,
+		slot: number
+	): NodeList<any> | undefined {
 		const isInactiveTriggerOrder =
 			mustBeTriggered(order) && !isTriggered(order);
 
@@ -344,7 +377,8 @@ export class DLOB {
 		} else if (order.oraclePriceOffset !== 0) {
 			type = 'floatingLimit';
 		} else {
-			type = 'limit';
+			const isResting = isRestingLimitOrder(order, slot);
+			type = isResting ? 'restingLimit' : 'takingLimit';
 		}
 
 		let subType: string;
@@ -365,6 +399,58 @@ export class DLOB {
 		];
 	}
 
+	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.orderLists.get(marketTypeStr)) {
+			const nodesToUpdate = [];
+			for (const node of nodeLists.takingLimit.ask.getGenerator()) {
+				if (!isRestingLimitOrder(node.order, slot)) {
+					continue;
+				}
+
+				nodesToUpdate.push({
+					side: 'ask',
+					node,
+				});
+			}
+
+			for (const node of nodeLists.takingLimit.bid.getGenerator()) {
+				if (!isRestingLimitOrder(node.order, slot)) {
+					continue;
+				}
+
+				nodesToUpdate.push({
+					side: 'bid',
+					node,
+				});
+			}
+
+			for (const nodeToUpdate of nodesToUpdate) {
+				const { side, node } = nodeToUpdate;
+				nodeLists.takingLimit[side].remove(node.order, node.userAccount);
+				nodeLists.restingLimit[side].insert(
+					node.order,
+					marketTypeStr,
+					node.userAccount
+				);
+			}
+		}
+	}
+
 	public getOrder(orderId: number, userAccount: PublicKey): Order | undefined {
 		for (const nodeList of this.getNodeLists()) {
 			const node = nodeList.get(orderId, userAccount);
@@ -393,24 +479,30 @@ export class DLOB {
 
 		const isAmmPaused = ammPaused(stateAccount, marketAccount);
 
-		const marketOrderNodesToFill: Array<NodeToFill> =
-			this.findMarketNodesToFill(
+		const minAuctionDuration = isVariant(marketType, 'perp')
+			? stateAccount.minPerpAuctionDuration
+			: 0;
+
+		const restingLimitOrderNodesToFill: Array<NodeToFill> =
+			this.findRestingLimitOrderNodesToFill(
 				marketIndex,
 				slot,
 				marketType,
 				oraclePriceData,
 				isAmmPaused,
+				minAuctionDuration,
 				fallbackAsk,
 				fallbackBid
 			);
 
-		const limitOrderNodesToFill: Array<NodeToFill> =
-			this.findLimitOrderNodesToFill(
+		const takingOrderNodesToFill: Array<NodeToFill> =
+			this.findTakingNodesToFill(
 				marketIndex,
 				slot,
 				marketType,
 				oraclePriceData,
 				isAmmPaused,
+				minAuctionDuration,
 				fallbackAsk,
 				fallbackBid
 			);
@@ -421,28 +513,30 @@ export class DLOB {
 			ts,
 			marketType
 		);
-		return marketOrderNodesToFill.concat(
-			limitOrderNodesToFill,
+		return restingLimitOrderNodesToFill.concat(
+			takingOrderNodesToFill,
 			expiredNodesToFill
 		);
 	}
 
-	public findLimitOrderNodesToFill(
+	public findRestingLimitOrderNodesToFill(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
 		isAmmPaused: boolean,
+		minAuctionDuration: number,
 		fallbackAsk: BN | undefined,
 		fallbackBid: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
-		const crossingNodes = this.findCrossingLimitOrders(
+		const crossingNodes = this.findCrossingRestingLimitOrders(
 			marketIndex,
 			slot,
 			marketType,
 			oraclePriceData,
+			minAuctionDuration,
 			fallbackAsk,
 			fallbackBid
 		);
@@ -452,7 +546,7 @@ export class DLOB {
 		}
 
 		if (fallbackBid && !isAmmPaused) {
-			const askGenerator = this.getLimitAsks(
+			const askGenerator = this.getRestingLimitAsks(
 				marketIndex,
 				slot,
 				marketType,
@@ -466,7 +560,8 @@ export class DLOB {
 				fallbackBid,
 				(askPrice, fallbackPrice) => {
 					return askPrice.lte(fallbackPrice);
-				}
+				},
+				minAuctionDuration
 			);
 
 			for (const askCrossingFallback of asksCrossingFallback) {
@@ -475,7 +570,7 @@ export class DLOB {
 		}
 
 		if (fallbackAsk && !isAmmPaused) {
-			const bidGenerator = this.getLimitBids(
+			const bidGenerator = this.getRestingLimitBids(
 				marketIndex,
 				slot,
 				marketType,
@@ -489,7 +584,8 @@ export class DLOB {
 				fallbackAsk,
 				(bidPrice, fallbackPrice) => {
 					return bidPrice.gte(fallbackPrice);
-				}
+				},
+				minAuctionDuration
 			);
 
 			for (const bidCrossingFallback of bidsCrossingFallback) {
@@ -500,25 +596,31 @@ export class DLOB {
 		return nodesToFill;
 	}
 
-	public findMarketNodesToFill(
+	public findTakingNodesToFill(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
 		isAmmPaused: boolean,
+		minAuctionDuration: number,
 		fallbackAsk: BN | undefined,
 		fallbackBid?: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
-		let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
+		let takingOrderGenerator = this.getTakingAsks(
+			marketIndex,
+			marketType,
+			slot,
+			oraclePriceData
+		);
 
-		const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(
+		const takingAsksCrossingBids = this.findTakingNodesCrossingMakerNodes(
 			marketIndex,
 			slot,
 			marketType,
 			oraclePriceData,
-			marketOrderGenerator,
+			takingOrderGenerator,
 			this.getMakerLimitBids.bind(this),
 			(takerPrice, makerPrice) => {
 				if (isVariant(marketType, 'spot')) {
@@ -534,37 +636,48 @@ export class DLOB {
 			},
 			fallbackAsk
 		);
-		for (const marketAskCrossingBid of marketAsksCrossingBids) {
-			nodesToFill.push(marketAskCrossingBid);
+		for (const takingAskCrossingBid of takingAsksCrossingBids) {
+			nodesToFill.push(takingAskCrossingBid);
 		}
 
 		if (fallbackBid && !isAmmPaused) {
-			marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
-			const marketAsksCrossingFallback =
+			takingOrderGenerator = this.getTakingAsks(
+				marketIndex,
+				marketType,
+				slot,
+				oraclePriceData
+			);
+			const takingAsksCrossingFallback =
 				this.findNodesCrossingFallbackLiquidity(
 					marketType,
 					slot,
 					oraclePriceData,
-					marketOrderGenerator,
+					takingOrderGenerator,
 					fallbackBid,
 					(takerPrice, fallbackPrice) => {
 						return takerPrice === undefined || takerPrice.lte(fallbackPrice);
-					}
+					},
+					minAuctionDuration
 				);
 
-			for (const marketAskCrossingFallback of marketAsksCrossingFallback) {
-				nodesToFill.push(marketAskCrossingFallback);
+			for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
+				nodesToFill.push(takingAskCrossingFallback);
 			}
 		}
 
-		marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
+		takingOrderGenerator = this.getTakingBids(
+			marketIndex,
+			marketType,
+			slot,
+			oraclePriceData
+		);
 
-		const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(
+		const takingBidsToFill = this.findTakingNodesCrossingMakerNodes(
 			marketIndex,
 			slot,
 			marketType,
 			oraclePriceData,
-			marketOrderGenerator,
+			takingOrderGenerator,
 			this.getMakerLimitAsks.bind(this),
 			(takerPrice, makerPrice) => {
 				if (isVariant(marketType, 'spot')) {
@@ -582,24 +695,30 @@ export class DLOB {
 			fallbackBid
 		);
 
-		for (const marketBidToFill of marketBidsToFill) {
-			nodesToFill.push(marketBidToFill);
+		for (const takingBidToFill of takingBidsToFill) {
+			nodesToFill.push(takingBidToFill);
 		}
 
 		if (fallbackAsk && !isAmmPaused) {
-			marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
-			const marketBidsCrossingFallback =
+			takingOrderGenerator = this.getTakingBids(
+				marketIndex,
+				marketType,
+				slot,
+				oraclePriceData
+			);
+			const takingBidsCrossingFallback =
 				this.findNodesCrossingFallbackLiquidity(
 					marketType,
 					slot,
 					oraclePriceData,
-					marketOrderGenerator,
+					takingOrderGenerator,
 					fallbackAsk,
 					(takerPrice, fallbackPrice) => {
 						return takerPrice === undefined || takerPrice.gte(fallbackPrice);
-					}
+					},
+					minAuctionDuration
 				);
-			for (const marketBidCrossingFallback of marketBidsCrossingFallback) {
+			for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
 				nodesToFill.push(marketBidCrossingFallback);
 			}
 		}
@@ -607,7 +726,7 @@ export class DLOB {
 		return nodesToFill;
 	}
 
-	public findMarketNodesCrossingLimitNodes(
+	public findTakingNodesCrossingMakerNodes(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
@@ -671,7 +790,7 @@ export class DLOB {
 				const newMakerOrder = { ...makerOrder };
 				newMakerOrder.baseAssetAmountFilled =
 					makerOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOrder(newMakerOrder).update(
+				this.getListForOrder(newMakerOrder, slot).update(
 					newMakerOrder,
 					makerNode.userAccount
 				);
@@ -679,7 +798,7 @@ export class DLOB {
 				const newTakerOrder = { ...takerOrder };
 				newTakerOrder.baseAssetAmountFilled =
 					takerOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOrder(newTakerOrder).update(
+				this.getListForOrder(newTakerOrder, slot).update(
 					newTakerOrder,
 					takerNode.userAccount
 				);
@@ -701,7 +820,8 @@ export class DLOB {
 		oraclePriceData: OraclePriceData,
 		nodeGenerator: Generator<DLOBNode>,
 		fallbackPrice: BN,
-		doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean
+		doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean,
+		minAuctionDuration: number
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -721,7 +841,12 @@ export class DLOB {
 
 			// fallback is available if auction is complete or it's a spot order
 			const fallbackAvailable =
-				isVariant(marketType, 'spot') || isAuctionComplete(node.order, slot);
+				isVariant(marketType, 'spot') ||
+				isFallbackAvailableLiquiditySource(
+					node.order,
+					minAuctionDuration,
+					slot
+				);
 
 			if (crosses && fallbackAvailable) {
 				nodesToFill.push({
@@ -752,12 +877,14 @@ export class DLOB {
 
 		// All bids/asks that can expire
 		const bidGenerators = [
-			nodeLists.limit.bid.getGenerator(),
+			nodeLists.takingLimit.bid.getGenerator(),
+			nodeLists.restingLimit.bid.getGenerator(),
 			nodeLists.floatingLimit.bid.getGenerator(),
 			nodeLists.market.bid.getGenerator(),
 		];
 		const askGenerators = [
-			nodeLists.limit.ask.getGenerator(),
+			nodeLists.takingLimit.ask.getGenerator(),
+			nodeLists.restingLimit.ask.getGenerator(),
 			nodeLists.floatingLimit.ask.getGenerator(),
 			nodeLists.market.ask.getGenerator(),
 		];
@@ -788,31 +915,40 @@ export class DLOB {
 	public findJitAuctionNodesToFill(
 		marketIndex: number,
 		slot: number,
+		oraclePriceData: OraclePriceData,
 		marketType: MarketType
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 		// Then see if there are orders still in JIT auction
-		for (const marketBid of this.getMarketBids(marketIndex, marketType)) {
-			if (!isAuctionComplete(marketBid.order, slot)) {
-				nodesToFill.push({
-					node: marketBid,
-				});
-			}
+		for (const marketBid of this.getTakingBids(
+			marketIndex,
+			marketType,
+			slot,
+			oraclePriceData
+		)) {
+			nodesToFill.push({
+				node: marketBid,
+			});
 		}
 
-		for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
-			if (!isAuctionComplete(marketAsk.order, slot)) {
-				nodesToFill.push({
-					node: marketAsk,
-				});
-			}
+		for (const marketAsk of this.getTakingAsks(
+			marketIndex,
+			marketType,
+			slot,
+			oraclePriceData
+		)) {
+			nodesToFill.push({
+				node: marketAsk,
+			});
 		}
 		return nodesToFill;
 	}
 
-	*getMarketBids(
+	*getTakingBids(
 		marketIndex: number,
-		marketType: MarketType
+		marketType: MarketType,
+		slot: number,
+		oraclePriceData: OraclePriceData
 	): Generator<DLOBNode> {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
@@ -820,18 +956,28 @@ export class DLOB {
 			return;
 		}
 
-		const generator = orderLists.market.bid.getGenerator();
-		for (const marketBidNode of generator) {
-			if (marketBidNode.isBaseFilled()) {
-				continue;
+		this.updateRestingLimitOrders(slot);
+
+		const generatorList = [
+			orderLists.market.bid.getGenerator(),
+			orderLists.takingLimit.bid.getGenerator(),
+		];
+
+		yield* this.getBestNode(
+			generatorList,
+			oraclePriceData,
+			slot,
+			(bestNode, currentNode) => {
+				return bestNode.order.slot.lt(currentNode.order.slot);
 			}
-			yield marketBidNode;
-		}
+		);
 	}
 
-	*getMarketAsks(
+	*getTakingAsks(
 		marketIndex: number,
-		marketType: MarketType
+		marketType: MarketType,
+		slot: number,
+		oraclePriceData: OraclePriceData
 	): Generator<DLOBNode> {
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		const orderLists = this.orderLists.get(marketTypeStr).get(marketIndex);
@@ -839,20 +985,33 @@ export class DLOB {
 			return;
 		}
 
-		const generator = orderLists.market.ask.getGenerator();
-		for (const marketAskNode of generator) {
-			if (marketAskNode.isBaseFilled()) {
-				continue;
+		this.updateRestingLimitOrders(slot);
+
+		const generatorList = [
+			orderLists.market.ask.getGenerator(),
+			orderLists.takingLimit.ask.getGenerator(),
+		];
+
+		yield* this.getBestNode(
+			generatorList,
+			oraclePriceData,
+			slot,
+			(bestNode, currentNode) => {
+				return bestNode.order.slot.lt(currentNode.order.slot);
 			}
-			yield marketAskNode;
-		}
+		);
 	}
 
 	private *getBestNode(
 		generatorList: Array<Generator<DLOBNode>>,
 		oraclePriceData: OraclePriceData,
 		slot: number,
-		compareFcn: (bestPrice: BN, currentPrice: BN) => boolean
+		compareFcn: (
+			bestDLOBNode: DLOBNode,
+			currentDLOBNode: DLOBNode,
+			slot: number,
+			oraclePriceData: OraclePriceData
+		) => boolean
 	): Generator<DLOBNode> {
 		const generators = generatorList.map((generator) => {
 			return {
@@ -876,18 +1035,7 @@ export class DLOB {
 					const bestValue = bestGenerator.next.value as DLOBNode;
 					const currentValue = currentGenerator.next.value as DLOBNode;
 
-					// 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)
+					return compareFcn(bestValue, currentValue, slot, oraclePriceData)
 						? bestGenerator
 						: currentGenerator;
 				}
@@ -908,7 +1056,7 @@ export class DLOB {
 		}
 	}
 
-	*getLimitAsks(
+	*getRestingLimitAsks(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
@@ -917,6 +1065,9 @@ export class DLOB {
 		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.orderLists.get(marketTypeStr).get(marketIndex);
 
@@ -925,7 +1076,7 @@ export class DLOB {
 		}
 
 		const generatorList = [
-			nodeLists.limit.ask.getGenerator(),
+			nodeLists.restingLimit.ask.getGenerator(),
 			nodeLists.floatingLimit.ask.getGenerator(),
 		];
 
@@ -933,15 +1084,17 @@ export class DLOB {
 			generatorList,
 			oraclePriceData,
 			slot,
-			(bestPrice, currentPrice) => {
-				return bestPrice.lt(currentPrice);
+			(bestNode, currentNode, slot, oraclePriceData) => {
+				return bestNode
+					.getPrice(oraclePriceData, slot)
+					.lt(currentNode.getPrice(oraclePriceData, slot));
 			}
 		);
 	}
 
 	/**
-	 * Filters the limit asks that are post only, have been place for sufficiently long or are above the fallback bid
-	 * Market orders can only fill against orders that meet this criteria
+	 * Filters the limit asks that are resting and do not cross fallback bid
+	 * Taking orders can only fill against orders that meet this criteria
 	 *
 	 * @returns
 	 */
@@ -952,28 +1105,23 @@ export class DLOB {
 		oraclePriceData: OraclePriceData,
 		fallbackBid?: BN
 	): Generator<DLOBNode> {
-		for (const node of this.getLimitAsks(
+		for (const node of this.getRestingLimitAsks(
 			marketIndex,
 			slot,
 			marketType,
 			oraclePriceData
 		)) {
-			if (this.isRestingLimitOrder(node.order, slot)) {
-				yield node;
-			} else if (
+			if (
 				fallbackBid &&
-				node.getPrice(oraclePriceData, slot).gt(fallbackBid)
+				node.getPrice(oraclePriceData, slot).lte(fallbackBid)
 			) {
-				yield node;
+				continue;
 			}
+			yield node;
 		}
 	}
 
-	isRestingLimitOrder(order: Order, slot: number): boolean {
-		return order.postOnly || new BN(slot).sub(order.slot).gte(new BN(45));
-	}
-
-	*getLimitBids(
+	*getRestingLimitBids(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
@@ -983,6 +1131,8 @@ export class DLOB {
 			throw new Error('Must provide OraclePriceData to get spot bids');
 		}
 
+		this.updateRestingLimitOrders(slot);
+
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
 
@@ -991,7 +1141,7 @@ export class DLOB {
 		}
 
 		const generatorList = [
-			nodeLists.limit.bid.getGenerator(),
+			nodeLists.restingLimit.bid.getGenerator(),
 			nodeLists.floatingLimit.bid.getGenerator(),
 		];
 
@@ -999,8 +1149,10 @@ export class DLOB {
 			generatorList,
 			oraclePriceData,
 			slot,
-			(bestPrice, currentPrice) => {
-				return bestPrice.gt(currentPrice);
+			(bestNode, currentNode, slot, oraclePriceData) => {
+				return bestNode
+					.getPrice(oraclePriceData, slot)
+					.gt(currentNode.getPrice(oraclePriceData, slot));
 			}
 		);
 	}
@@ -1018,20 +1170,19 @@ export class DLOB {
 		oraclePriceData: OraclePriceData,
 		fallbackAsk?: BN
 	): Generator<DLOBNode> {
-		for (const node of this.getLimitBids(
+		for (const node of this.getRestingLimitBids(
 			marketIndex,
 			slot,
 			marketType,
 			oraclePriceData
 		)) {
-			if (this.isRestingLimitOrder(node.order, slot)) {
-				yield node;
-			} else if (
+			if (
 				fallbackAsk &&
-				node.getPrice(oraclePriceData, slot).lt(fallbackAsk)
+				node.getPrice(oraclePriceData, slot).gte(fallbackAsk)
 			) {
-				yield node;
+				continue;
 			}
+			yield node;
 		}
 	}
 
@@ -1047,8 +1198,8 @@ export class DLOB {
 		}
 
 		const generatorList = [
-			this.getMarketAsks(marketIndex, marketType),
-			this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData),
+			this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData),
+			this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData),
 		];
 
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
@@ -1060,8 +1211,29 @@ export class DLOB {
 			generatorList,
 			oraclePriceData,
 			slot,
-			(bestPrice, currentPrice) => {
-				return bestPrice.lt(currentPrice);
+			(bestNode, currentNode, slot, oraclePriceData) => {
+				const bestNodeTaking = bestNode.order
+					? isTakingOrder(bestNode.order, slot)
+					: false;
+				const currentNodeTaking = currentNode.order
+					? isTakingOrder(currentNode.order, slot)
+					: false;
+
+				if (bestNodeTaking && currentNodeTaking) {
+					return bestNode.order.slot.lt(currentNode.order.slot);
+				}
+
+				if (bestNodeTaking) {
+					return true;
+				}
+
+				if (currentNodeTaking) {
+					return false;
+				}
+
+				return bestNode
+					.getPrice(oraclePriceData, slot)
+					.lt(currentNode.getPrice(oraclePriceData, slot));
 			}
 		);
 	}
@@ -1078,8 +1250,8 @@ export class DLOB {
 		}
 
 		const generatorList = [
-			this.getMarketBids(marketIndex, marketType),
-			this.getLimitBids(marketIndex, slot, marketType, oraclePriceData),
+			this.getTakingBids(marketIndex, marketType, slot, oraclePriceData),
+			this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData),
 		];
 
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
@@ -1091,40 +1263,64 @@ export class DLOB {
 			generatorList,
 			oraclePriceData,
 			slot,
-			(bestPrice, currentPrice) => {
-				return bestPrice.gt(currentPrice);
+			(bestNode, currentNode, slot, oraclePriceData) => {
+				const bestNodeTaking = bestNode.order
+					? isTakingOrder(bestNode.order, slot)
+					: false;
+				const currentNodeTaking = currentNode.order
+					? isTakingOrder(currentNode.order, slot)
+					: false;
+
+				if (bestNodeTaking && currentNodeTaking) {
+					return bestNode.order.slot.lt(currentNode.order.slot);
+				}
+
+				if (bestNodeTaking) {
+					return true;
+				}
+
+				if (currentNodeTaking) {
+					return false;
+				}
+
+				return bestNode
+					.getPrice(oraclePriceData, slot)
+					.gt(currentNode.getPrice(oraclePriceData, slot));
 			}
 		);
 	}
 
-	findCrossingLimitOrders(
+	findCrossingRestingLimitOrders(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
+		minAuctionDuration: number,
 		fallbackAsk: BN | undefined,
 		fallbackBid: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
-		for (const askNode of this.getLimitAsks(
+		for (const askNode of this.getRestingLimitAsks(
 			marketIndex,
 			slot,
 			marketType,
 			oraclePriceData
 		)) {
-			for (const bidNode of this.getLimitBids(
+			const bidGenerator = this.getRestingLimitBids(
 				marketIndex,
 				slot,
 				marketType,
 				oraclePriceData
-			)) {
+			);
+
+			for (const bidNode of bidGenerator) {
 				const bidPrice = bidNode.getPrice(oraclePriceData, slot);
 				const askPrice = askNode.getPrice(oraclePriceData, slot);
 
-				// orders don't cross - we're done walking the book
+				// orders don't cross
 				if (bidPrice.lt(askPrice)) {
-					return nodesToFill;
+					break;
 				}
 
 				const bidOrder = bidNode.order;
@@ -1132,17 +1328,27 @@ export class DLOB {
 
 				// Can't match orders from the same user
 				const sameUser = bidNode.userAccount.equals(askNode.userAccount);
-				if (sameUser || (bidOrder.postOnly && askOrder.postOnly)) {
+				if (sameUser) {
 					continue;
 				}
 
-				const { takerNode, makerNode } = this.determineMakerAndTaker(
-					askNode,
-					bidNode
-				);
+				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;
 
 				// extra guard against bad fills for limit orders where auction is incomplete
-				if (!isAuctionComplete(takerNode.order, slot)) {
+				if (
+					!isFallbackAvailableLiquiditySource(
+						takerNode.order,
+						minAuctionDuration,
+						slot
+					)
+				) {
 					let bidPrice: BN;
 					let askPrice: BN;
 					if (isVariant(takerNode.order.direction, 'long')) {
@@ -1176,7 +1382,7 @@ export class DLOB {
 				const newBidOrder = { ...bidOrder };
 				newBidOrder.baseAssetAmountFilled =
 					bidOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOrder(newBidOrder).update(
+				this.getListForOrder(newBidOrder, slot).update(
 					newBidOrder,
 					bidNode.userAccount
 				);
@@ -1185,7 +1391,7 @@ export class DLOB {
 				const newAskOrder = { ...askOrder };
 				newAskOrder.baseAssetAmountFilled =
 					askOrder.baseAssetAmountFilled.add(baseFilled);
-				this.getListForOrder(newAskOrder).update(
+				this.getListForOrder(newAskOrder, slot).update(
 					newAskOrder,
 					askNode.userAccount
 				);
@@ -1207,27 +1413,25 @@ export class DLOB {
 	determineMakerAndTaker(
 		askNode: DLOBNode,
 		bidNode: DLOBNode
-	): { takerNode: DLOBNode; makerNode: DLOBNode } {
-		if (bidNode.order.postOnly) {
-			return {
-				takerNode: askNode,
-				makerNode: bidNode,
-			};
-		} else if (askNode.order.postOnly) {
-			return {
-				takerNode: bidNode,
-				makerNode: askNode,
-			};
-		} else if (askNode.order.slot.lt(bidNode.order.slot)) {
+	): { takerNode: DLOBNode; makerNode: DLOBNode } | undefined {
+		const askSlot = askNode.order.slot.add(
+			new BN(askNode.order.auctionDuration)
+		);
+		const bidSlot = bidNode.order.slot.add(
+			new BN(bidNode.order.auctionDuration)
+		);
+		if (askSlot.lte(bidSlot) && !bidNode.order.postOnly) {
 			return {
 				takerNode: bidNode,
 				makerNode: askNode,
 			};
-		} else {
+		} else if (bidSlot.lte(askSlot) && !askNode.order.postOnly) {
 			return {
 				takerNode: askNode,
 				makerNode: bidNode,
 			};
+		} else {
+			return undefined;
 		}
 	}
 
@@ -1288,11 +1492,9 @@ export class DLOB {
 		if (triggerAboveList) {
 			for (const node of triggerAboveList.getGenerator()) {
 				if (oraclePrice.gt(node.order.triggerPrice)) {
-					if (isAuctionComplete(node.order, slot)) {
-						nodesToTrigger.push({
-							node: node,
-						});
-					}
+					nodesToTrigger.push({
+						node: node,
+					});
 				} else {
 					break;
 				}
@@ -1305,11 +1507,9 @@ export class DLOB {
 		if (triggerBelowList) {
 			for (const node of triggerBelowList.getGenerator()) {
 				if (oraclePrice.lt(node.order.triggerPrice)) {
-					if (isAuctionComplete(node.order, slot)) {
-						nodesToTrigger.push({
-							node: node,
-						});
-					}
+					nodesToTrigger.push({
+						node: node,
+					});
 				} else {
 					break;
 				}
@@ -1438,8 +1638,10 @@ export class DLOB {
 
 	*getNodeLists(): Generator<NodeList<DLOBNodeType>> {
 		for (const [_, nodeLists] of this.orderLists.get('perp')) {
-			yield nodeLists.limit.bid;
-			yield nodeLists.limit.ask;
+			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;
@@ -1449,8 +1651,10 @@ export class DLOB {
 		}
 
 		for (const [_, nodeLists] of this.orderLists.get('spot')) {
-			yield nodeLists.limit.bid;
-			yield nodeLists.limit.ask;
+			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;