@drift-labs/sdk 2.49.0-beta.3 → 2.49.0-beta.4

package/VERSION

@@ -1 +1 @@
-2.49.0-beta.3
+2.49.0-beta.4

package/lib/dlob/DLOB.d.ts

@@ -68,11 +68,15 @@ export declare class DLOB {
     updateRestingLimitOrdersForMarketType(slot: number, marketTypeStr: MarketTypeStr): void;
     getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
+    getMakerRebate(marketType: MarketType, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): {
+        makerRebateNumerator: number;
+        makerRebateDenominator: number;
+    };
     mergeNodesToFill(restingLimitOrderNodesToFill: NodeToFill[], takingOrderNodesToFill: NodeToFill[]): NodeToFill[];
-    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
+    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, makerRebateNumerator: number, makerRebateDenominator: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     findTakingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
     findTakingNodesCrossingMakerNodes(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[];
-    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, fallbackPrice: BN, doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean, minAuctionDuration: number): NodeToFill[];
+    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, doesCross: (nodePrice: BN | undefined) => boolean, minAuctionDuration: number): NodeToFill[];
     findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
     findJitAuctionNodesToFill(marketIndex: number, slot: number, oraclePriceData: OraclePriceData, marketType: MarketType): NodeToFill[];
     getTakingBids(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData): Generator<DLOBNode>;

package/lib/dlob/DLOB.js

@@ -304,7 +304,8 @@ class DLOB {
         const minAuctionDuration = (0, __1.isVariant)(marketType, 'perp')
             ? stateAccount.minPerpAuctionDuration
             : 0;
-        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
+        const { makerRebateNumerator, makerRebateDenominator } = this.getMakerRebate(marketType, stateAccount, marketAccount);
+        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, makerRebateNumerator, makerRebateDenominator, fallbackAsk, fallbackBid);
         const takingOrderNodesToFill = this.findTakingNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
         // get expired market nodes
         const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
@@ -314,6 +315,28 @@ class DLOB {
         }
         return this.mergeNodesToFill(restingLimitOrderNodesToFill, takingOrderNodesToFill).concat(expiredNodesToFill);
     }
+    getMakerRebate(marketType, stateAccount, marketAccount) {
+        let makerRebateNumerator;
+        let makerRebateDenominator;
+        if ((0, __1.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, takingOrderNodesToFill) {
         const mergedNodesToFill = new Map();
         const mergeNodesToFillHelper = (nodesToFillArray) => {
@@ -336,7 +359,7 @@ class DLOB {
         mergeNodesToFillHelper(takingOrderNodesToFill);
         return Array.from(mergedNodesToFill.values());
     }
-    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid) {
+    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, makerRebateNumerator, makerRebateDenominator, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         const crossingNodes = this.findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
         for (const crossingNode of crossingNodes) {
@@ -344,8 +367,9 @@ class DLOB {
         }
         if (fallbackBid && !isAmmPaused) {
             const askGenerator = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
-            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, fallbackBid, (askPrice, fallbackPrice) => {
-                return askPrice.lte(fallbackPrice);
+            const fallbackBidWithBuffer = fallbackBid.sub(fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator));
+            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, (askPrice) => {
+                return askPrice.lte(fallbackBidWithBuffer);
             }, minAuctionDuration);
             for (const askCrossingFallback of asksCrossingFallback) {
                 nodesToFill.push(askCrossingFallback);
@@ -353,8 +377,9 @@ class DLOB {
         }
         if (fallbackAsk && !isAmmPaused) {
             const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
-            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, fallbackAsk, (bidPrice, fallbackPrice) => {
-                return bidPrice.gte(fallbackPrice);
+            const fallbackAskWithBuffer = fallbackAsk.add(fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator));
+            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, (bidPrice) => {
+                return bidPrice.gte(fallbackAskWithBuffer);
             }, minAuctionDuration);
             for (const bidCrossingFallback of bidsCrossingFallback) {
                 nodesToFill.push(bidCrossingFallback);
@@ -381,8 +406,8 @@ class DLOB {
         }
         if (fallbackBid && !isAmmPaused) {
             takingOrderGenerator = this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData);
-            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackBid, (takerPrice, fallbackPrice) => {
-                return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, (takerPrice) => {
+                return takerPrice === undefined || takerPrice.lte(fallbackBid);
             }, minAuctionDuration);
             for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
                 nodesToFill.push(takingAskCrossingFallback);
@@ -405,8 +430,8 @@ class DLOB {
         }
         if (fallbackAsk && !isAmmPaused) {
             takingOrderGenerator = this.getTakingBids(marketIndex, marketType, slot, oraclePriceData);
-            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackAsk, (takerPrice, fallbackPrice) => {
-                return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, (takerPrice) => {
+                return takerPrice === undefined || takerPrice.gte(fallbackAsk);
             }, minAuctionDuration);
             for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
                 nodesToFill.push(marketBidCrossingFallback);
@@ -456,7 +481,7 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, fallbackPrice, doesCross, minAuctionDuration) {
+    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, doesCross, minAuctionDuration) {
         var _a;
         const nodesToFill = new Array();
         let nextNode = nodeGenerator.next();
@@ -468,7 +493,7 @@ class DLOB {
             }
             const nodePrice = (0, __1.getLimitPrice)(node.order, oraclePriceData, slot);
             // order crosses if there is no limit price or it crosses fallback price
-            const crosses = doesCross(nodePrice, fallbackPrice);
+            const crosses = doesCross(nodePrice);
             // fallback is available if auction is complete or it's a spot order
             const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') ||
                 (0, __1.isFallbackAvailableLiquiditySource)(node.order, minAuctionDuration, slot);

package/lib/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.49.0-beta.3",
+	"version": "2.49.0-beta.4",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/dlob/DLOB.ts

@@ -504,6 +504,9 @@ export class DLOB {
 			? stateAccount.minPerpAuctionDuration
 			: 0;
 
+		const { makerRebateNumerator, makerRebateDenominator } =
+			this.getMakerRebate(marketType, stateAccount, marketAccount);
+
 		const restingLimitOrderNodesToFill: Array<NodeToFill> =
 			this.findRestingLimitOrderNodesToFill(
 				marketIndex,
@@ -512,6 +515,8 @@ export class DLOB {
 				oraclePriceData,
 				isAmmPaused,
 				minAuctionDuration,
+				makerRebateNumerator,
+				makerRebateDenominator,
 				fallbackAsk,
 				fallbackBid
 			);
@@ -549,6 +554,34 @@ export class DLOB {
 		).concat(expiredNodesToFill);
 	}
 
+	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[]
@@ -590,6 +623,8 @@ export class DLOB {
 		oraclePriceData: OraclePriceData,
 		isAmmPaused: boolean,
 		minAuctionDuration: number,
+		makerRebateNumerator: number,
+		makerRebateDenominator: number,
 		fallbackAsk: BN | undefined,
 		fallbackBid: BN | undefined
 	): NodeToFill[] {
@@ -613,14 +648,18 @@ export class DLOB {
 				marketType,
 				oraclePriceData
 			);
+
+			const fallbackBidWithBuffer = fallbackBid.sub(
+				fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator)
+			);
+
 			const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(
 				marketType,
 				slot,
 				oraclePriceData,
 				askGenerator,
-				fallbackBid,
-				(askPrice, fallbackPrice) => {
-					return askPrice.lte(fallbackPrice);
+				(askPrice) => {
+					return askPrice.lte(fallbackBidWithBuffer);
 				},
 				minAuctionDuration
 			);
@@ -637,14 +676,18 @@ export class DLOB {
 				marketType,
 				oraclePriceData
 			);
+
+			const fallbackAskWithBuffer = fallbackAsk.add(
+				fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator)
+			);
+
 			const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(
 				marketType,
 				slot,
 				oraclePriceData,
 				bidGenerator,
-				fallbackAsk,
-				(bidPrice, fallbackPrice) => {
-					return bidPrice.gte(fallbackPrice);
+				(bidPrice) => {
+					return bidPrice.gte(fallbackAskWithBuffer);
 				},
 				minAuctionDuration
 			);
@@ -713,9 +756,8 @@ export class DLOB {
 					slot,
 					oraclePriceData,
 					takingOrderGenerator,
-					fallbackBid,
-					(takerPrice, fallbackPrice) => {
-						return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+					(takerPrice) => {
+						return takerPrice === undefined || takerPrice.lte(fallbackBid);
 					},
 					minAuctionDuration
 				);
@@ -771,9 +813,8 @@ export class DLOB {
 					slot,
 					oraclePriceData,
 					takingOrderGenerator,
-					fallbackAsk,
-					(takerPrice, fallbackPrice) => {
-						return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+					(takerPrice) => {
+						return takerPrice === undefined || takerPrice.gte(fallbackAsk);
 					},
 					minAuctionDuration
 				);
@@ -875,8 +916,7 @@ export class DLOB {
 		slot: number,
 		oraclePriceData: OraclePriceData,
 		nodeGenerator: Generator<DLOBNode>,
-		fallbackPrice: BN,
-		doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean,
+		doesCross: (nodePrice: BN | undefined) => boolean,
 		minAuctionDuration: number
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
@@ -893,7 +933,7 @@ export class DLOB {
 			const nodePrice = getLimitPrice(node.order, oraclePriceData, slot);
 
 			// order crosses if there is no limit price or it crosses fallback price
-			const crosses = doesCross(nodePrice, fallbackPrice);
+			const crosses = doesCross(nodePrice);
 
 			// fallback is available if auction is complete or it's a spot order
 			const fallbackAvailable =

package/src/types.ts

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

package/tests/dlob/helpers.ts

@@ -539,15 +539,13 @@ export const mockStateAccount: StateAccount = {
 				feeNumerator: 0,
 				feeDenominator: 0,
 				makerRebateNumerator: 0,
-				makerRebateDenominator: 0,
+				makerRebateDenominator: 1,
 				referrerRewardNumerator: 0,
 				referrerRewardDenominator: 0,
 				refereeFeeNumerator: 0,
 				refereeFeeDenominator: 0,
 			},
 		],
-		makerRebateNumerator: new BN(0),
-		makerRebateDenominator: new BN(0),
 		fillerRewardStructure: {
 			rewardNumerator: new BN(0),
 			rewardDenominator: new BN(0),
@@ -565,15 +563,13 @@ export const mockStateAccount: StateAccount = {
 				feeNumerator: 0,
 				feeDenominator: 0,
 				makerRebateNumerator: 0,
-				makerRebateDenominator: 0,
+				makerRebateDenominator: 1,
 				referrerRewardNumerator: 0,
 				referrerRewardDenominator: 0,
 				refereeFeeNumerator: 0,
 				refereeFeeDenominator: 0,
 			},
 		],
-		makerRebateNumerator: new BN(0),
-		makerRebateDenominator: new BN(0),
 		fillerRewardStructure: {
 			rewardNumerator: new BN(0),
 			rewardDenominator: new BN(0),

package/tests/dlob/test.ts

@@ -1914,6 +1914,8 @@ describe('DLOB Perp Tests', () => {
 			},
 			false,
 			10,
+			0,
+			1,
 			undefined,
 			undefined
 		);
@@ -2059,6 +2061,8 @@ describe('DLOB Perp Tests', () => {
 			},
 			false,
 			10,
+			0,
+			1,
 			undefined,
 			undefined
 		);
@@ -2267,6 +2271,190 @@ describe('DLOB Perp Tests', () => {
 		expect(nodesToFillAfter[1].makerNodes[0]?.order?.orderId).to.equal(3);
 	});
 
+	it('Test post only bid fills against fallback', async () => {
+		const vAsk = new BN(150);
+		const vBid = new BN(100);
+
+		const user0 = Keypair.generate();
+
+		const dlob = new DLOB();
+		const marketIndex = 0;
+
+		const makerRebateNumerator = 1;
+		const makerRebateDenominator = 10;
+
+		// post only bid same as ask
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			1, // orderId
+			marketIndex,
+			vAsk, // same price as vAsk
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk,
+			undefined,
+			undefined,
+			undefined,
+			true
+		);
+
+		// should have no crossing orders
+		const nodesToFillBefore = dlob.findRestingLimitOrderNodesToFill(
+			marketIndex,
+			12, // auction over
+			MarketType.PERP,
+			{
+				price: vBid.add(vAsk).div(new BN(2)),
+				slot: new BN(12),
+				confidence: new BN(1),
+				hasSufficientNumberOfDataPoints: true,
+			},
+			false,
+			10,
+			makerRebateNumerator,
+			makerRebateDenominator,
+			vAsk,
+			vBid
+		);
+		expect(nodesToFillBefore.length).to.equal(0);
+
+		// post only bid crosses ask
+		const price = vAsk.add(vAsk.muln(makerRebateNumerator).divn(makerRebateDenominator));
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			2, // orderId
+			marketIndex,
+			price, // crosses vask
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk,
+			undefined,
+			undefined,
+			undefined,
+			true
+		);
+
+		// should have no crossing orders
+		const nodesToFillAfter = dlob.findRestingLimitOrderNodesToFill(
+			marketIndex,
+			12, // auction over
+			MarketType.PERP,
+			{
+				price: vBid.add(vAsk).div(new BN(2)),
+				slot: new BN(12),
+				confidence: new BN(1),
+				hasSufficientNumberOfDataPoints: true,
+			},
+			false,
+			10,
+			makerRebateNumerator,
+			makerRebateDenominator,
+			vAsk,
+			vBid
+		);
+		expect(nodesToFillAfter.length).to.equal(1);
+	});
+
+	it('Test post only ask fills against fallback', async () => {
+		const vAsk = new BN(150);
+		const vBid = new BN(100);
+
+		const user0 = Keypair.generate();
+
+		const dlob = new DLOB();
+		const marketIndex = 0;
+
+		const makerRebateNumerator = 1;
+		const makerRebateDenominator = 10;
+
+		// post only bid same as ask
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			1, // orderId
+			marketIndex,
+			vBid, // same price as vAsk
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk,
+			undefined,
+			undefined,
+			undefined,
+			true
+		);
+
+		// should have no crossing orders
+		const nodesToFillBefore = dlob.findRestingLimitOrderNodesToFill(
+			marketIndex,
+			12, // auction over
+			MarketType.PERP,
+			{
+				price: vBid.add(vAsk).div(new BN(2)),
+				slot: new BN(12),
+				confidence: new BN(1),
+				hasSufficientNumberOfDataPoints: true,
+			},
+			false,
+			10,
+			makerRebateNumerator,
+			makerRebateDenominator,
+			vAsk,
+			vBid
+		);
+		expect(nodesToFillBefore.length).to.equal(0);
+
+		// post only bid crosses ask
+		const price = vBid.sub(vAsk.muln(makerRebateNumerator).divn(makerRebateDenominator));
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			2, // orderId
+			marketIndex,
+			price, // crosses vask
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk,
+			undefined,
+			undefined,
+			undefined,
+			true
+		);
+
+		// should have no crossing orders
+		const nodesToFillAfter = dlob.findRestingLimitOrderNodesToFill(
+			marketIndex,
+			12, // auction over
+			MarketType.PERP,
+			{
+				price: vBid.add(vAsk).div(new BN(2)),
+				slot: new BN(12),
+				confidence: new BN(1),
+				hasSufficientNumberOfDataPoints: true,
+			},
+			false,
+			10,
+			makerRebateNumerator,
+			makerRebateDenominator,
+			vAsk,
+			vBid
+		);
+		expect(nodesToFillAfter.length).to.equal(1);
+	});
+
 	it('Test trigger orders', () => {
 		const vAsk = new BN(15);
 		const vBid = new BN(8);
@@ -2901,6 +3089,8 @@ describe('DLOB Perp Tests', () => {
 			oracle,
 			false,
 			10,
+			0,
+			1,
 			undefined,
 			undefined
 		);