@zoralabs/limit-orders 0.2.2 → 0.2.4

package/test/unit/LimitOrderCreateUnit.t.sol

@@ -135,7 +135,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests validation with valid single order
-    function test_validateOrderInputs_singleOrder_success() public {
+    function test_validateOrderInputs_singleOrder_success() public view {
         uint256[] memory sizes = new uint256[](1);
         int24[] memory ticks = new int24[](1);
         sizes[0] = 1000;
@@ -146,7 +146,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests validation with multiple orders (loop iterations)
-    function test_validateOrderInputs_multipleOrders_sumsTotal() public {
+    function test_validateOrderInputs_multipleOrders_sumsTotal() public view {
         uint256[] memory sizes = new uint256[](5);
         int24[] memory ticks = new int24[](5);
 
@@ -160,7 +160,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests validation loop with many iterations
-    function test_validateOrderInputs_manyOrders_loopIterates() public {
+    function test_validateOrderInputs_manyOrders_loopIterates() public view {
         uint256[] memory sizes = new uint256[](10);
         int24[] memory ticks = new int24[](10);
 
@@ -222,7 +222,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests tick calculation for currency0
-    function test_calculateTicks_currency0_setsCorrectRange() public {
+    function test_calculateTicks_currency0_setsCorrectRange() public view {
         bool isCurrency0 = true;
         int24 orderTick = 1000;
         int24 spacing = 200;
@@ -234,7 +234,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests tick calculation for currency1
-    function test_calculateTicks_currency1_setsCorrectRange() public {
+    function test_calculateTicks_currency1_setsCorrectRange() public view {
         bool isCurrency0 = false;
         int24 orderTick = 1000;
         int24 spacing = 200;
@@ -246,7 +246,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests tick calculation with negative ticks
-    function test_calculateTicks_negativeTicks_handlesCorrectly() public {
+    function test_calculateTicks_negativeTicks_handlesCorrectly() public view {
         bool isCurrency0 = true;
         int24 orderTick = -1000;
         int24 spacing = 200;
@@ -258,7 +258,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests realized size for currency0 with negative amount0
-    function test_calculateRealizedSize_currency0_negativeAmount_returnsSize() public {
+    function test_calculateRealizedSize_currency0_negativeAmount_returnsSize() public view {
         bool isCurrency0 = true;
         int128 amount0 = -1000;
         int128 amount1 = 500;
@@ -268,7 +268,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests realized size for currency0 with positive amount0
-    function test_calculateRealizedSize_currency0_positiveAmount_returnsZero() public {
+    function test_calculateRealizedSize_currency0_positiveAmount_returnsZero() public view {
         bool isCurrency0 = true;
         int128 amount0 = 1000; // Positive
         int128 amount1 = -500;
@@ -278,7 +278,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests realized size for currency1 with negative amount1
-    function test_calculateRealizedSize_currency1_negativeAmount_returnsSize() public {
+    function test_calculateRealizedSize_currency1_negativeAmount_returnsSize() public view {
         bool isCurrency0 = false;
         int128 amount0 = 500;
         int128 amount1 = -1000;
@@ -288,7 +288,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests realized size for currency1 with positive amount1
-    function test_calculateRealizedSize_currency1_positiveAmount_returnsZero() public {
+    function test_calculateRealizedSize_currency1_positiveAmount_returnsZero() public view {
         bool isCurrency0 = false;
         int128 amount0 = -500;
         int128 amount1 = 1000; // Positive
@@ -298,7 +298,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests realized size with zero amounts
-    function test_calculateRealizedSize_zeroAmounts_returnsZero() public {
+    function test_calculateRealizedSize_zeroAmounts_returnsZero() public view {
         bool isCurrency0 = true;
         int128 amount0 = 0;
         int128 amount1 = 0;
@@ -308,7 +308,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests refund when realized < requested
-    function test_calculateRefund_partialRealization_returnsRefund() public {
+    function test_calculateRefund_partialRealization_returnsRefund() public view {
         uint128 realizedSize = 800;
         uint128 requestedSize = 1000;
 
@@ -317,7 +317,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests refund when realized == requested (no refund)
-    function test_calculateRefund_fullRealization_noRefund() public {
+    function test_calculateRefund_fullRealization_noRefund() public view {
         uint128 realizedSize = 1000;
         uint128 requestedSize = 1000;
 
@@ -326,7 +326,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests refund when realized > requested (edge case)
-    function test_calculateRefund_overRealization_noRefund() public {
+    function test_calculateRefund_overRealization_noRefund() public view {
         uint128 realizedSize = 1200;
         uint128 requestedSize = 1000;
 
@@ -344,7 +344,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests validation with empty arrays
-    function test_validateOrderInputs_emptyArrays_success() public {
+    function test_validateOrderInputs_emptyArrays_success() public view {
         uint256[] memory sizes = new uint256[](0);
         int24[] memory ticks = new int24[](0);
 
@@ -353,7 +353,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests tick calculation with zero spacing (edge case)
-    function test_calculateTicks_zeroSpacing_noChange() public {
+    function test_calculateTicks_zeroSpacing_noChange() public view {
         bool isCurrency0 = true;
         int24 orderTick = 1000;
         int24 spacing = 0;
@@ -365,7 +365,7 @@ contract LimitOrderCreateUnitTest is Test {
     }
 
     /// @notice Tests realized size calculation with large negative values
-    function test_calculateRealizedSize_largeNegativeValue_handlesCorrectly() public {
+    function test_calculateRealizedSize_largeNegativeValue_handlesCorrectly() public view {
         bool isCurrency0 = true;
         int128 amount0 = -1000000000; // Large negative value
         int128 amount1 = 0;

package/test/unit/SwapLimitOrdersUnit.t.sol

@@ -143,7 +143,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests validate with all valid inputs (success case)
-    function test_validate_success_validParams() public {
+    function test_validate_success_validParams() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](3);
         params.percentages = new uint256[](3);
@@ -160,7 +160,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests validate with percentages exactly at 100%
-    function test_validate_success_exactlyOneHundredPercent() public {
+    function test_validate_success_exactlyOneHundredPercent() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -175,7 +175,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests validate loop iterations (line 65 for loop with multiple iterations)
-    function test_validate_multipleIterations_checksAllElements() public {
+    function test_validate_multipleIterations_checksAllElements() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](5); // 5 elements to iterate
         params.percentages = new uint256[](5);
@@ -190,7 +190,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests validate with single element (loop executes once)
-    function test_validate_singleElement_loopExecutesOnce() public {
+    function test_validate_singleElement_loopExecutesOnce() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -203,7 +203,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with totalSize of zero returns empty
-    function test_computeOrders_zeroSize_returnsEmpty() public {
+    function test_computeOrders_zeroSize_returnsEmpty() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -233,7 +233,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with small totalSize creates orders
-    function test_computeOrders_smallSize_createsOrders() public {
+    function test_computeOrders_smallSize_createsOrders() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -246,14 +246,7 @@ contract SwapLimitOrdersUnitTest is Test {
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            totalSize,
-            baseTick,
-            sqrtPriceX96,
-            params
-        );
+        (Orders memory orders, uint128 allocated, ) = SwapLimitOrders.computeOrders(testKey, true, totalSize, baseTick, sqrtPriceX96, params);
 
         // Should create orders
         assertEq(orders.sizes.length, 2, "should create 2 orders");
@@ -264,7 +257,7 @@ contract SwapLimitOrdersUnitTest is Test {
     /// @notice Tests computeOrders with multiple orders (verifying skip logic exists even if hard to trigger)
     /// @dev Note: Zero-rounding skip is virtually impossible with reasonable sizes and PERCENT_SCALE=10000
     ///      since even 1 basis point of 1e18 = 1e14. The skip logic exists for safety in edge cases.
-    function test_computeOrders_multipleOrders_createsAll() public {
+    function test_computeOrders_multipleOrders_createsAll() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -277,14 +270,7 @@ contract SwapLimitOrdersUnitTest is Test {
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            totalSize,
-            baseTick,
-            sqrtPriceX96,
-            params
-        );
+        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(testKey, true, totalSize, baseTick, sqrtPriceX96, params);
 
         // Both orders should be created
         assertEq(orders.sizes.length, 2, "should create 2 orders");
@@ -292,7 +278,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders loop with many iterations (line 105 for loop)
-    function test_computeOrders_manyOrders_loopIteratesMultipleTimes() public {
+    function test_computeOrders_manyOrders_loopIteratesMultipleTimes() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](6); // Many orders
         params.percentages = new uint256[](6);
@@ -306,14 +292,7 @@ contract SwapLimitOrdersUnitTest is Test {
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            totalSize,
-            baseTick,
-            sqrtPriceX96,
-            params
-        );
+        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(testKey, true, totalSize, baseTick, sqrtPriceX96, params);
 
         // All 6 orders should be created
         assertEq(orders.sizes.length, 6, "should create 6 orders");
@@ -321,7 +300,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with single order (loop executes once)
-    function test_computeOrders_singleOrder_loopExecutesOnce() public {
+    function test_computeOrders_singleOrder_loopExecutesOnce() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -332,21 +311,14 @@ contract SwapLimitOrdersUnitTest is Test {
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            totalSize,
-            baseTick,
-            sqrtPriceX96,
-            params
-        );
+        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(testKey, true, totalSize, baseTick, sqrtPriceX96, params);
 
         assertEq(orders.sizes.length, 1, "should create 1 order");
         assertEq(orders.ticks.length, 1, "should have 1 tick");
     }
 
     /// @notice Tests computeOrders with large totalSize and valid percentages
-    function test_computeOrders_largeSize_allocatesCorrectly() public {
+    function test_computeOrders_largeSize_allocatesCorrectly() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -423,7 +395,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with extreme multiples (tick clamping)
-    function test_computeOrders_extremeMultiples_clampsToMaxTick() public {
+    function test_computeOrders_extremeMultiples_clampsToMaxTick() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -444,7 +416,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders for currency1 (isCurrency0 = false) - tests line 147 branch
-    function test_computeOrders_currency1_ticksBelowBase() public {
+    function test_computeOrders_currency1_ticksBelowBase() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -466,7 +438,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with sqrt price overflow (line 155 branch: scaled > type(uint160).max)
-    function test_computeOrders_sqrtPriceOverflow_clampsToMax() public {
+    function test_computeOrders_sqrtPriceOverflow_clampsToMax() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -487,7 +459,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders near minimum tick boundary (line 169 branch: aligned < minTick)
-    function test_computeOrders_nearMinTick_clampsToMin() public {
+    function test_computeOrders_nearMinTick_clampsToMin() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -507,7 +479,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with tick too close to base (line 170: isCurrency0 && aligned < minAway)
-    function test_computeOrders_currency0_tooCloseToBase_clampsToMinAway() public {
+    function test_computeOrders_currency0_tooCloseToBase_clampsToMinAway() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -526,7 +498,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests computeOrders with tick too close to base (line 171: !isCurrency0 && aligned > minAway)
-    function test_computeOrders_currency1_tooCloseToBase_clampsToMinAway() public {
+    function test_computeOrders_currency1_tooCloseToBase_clampsToMinAway() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -562,7 +534,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when not a coin buy (first condition in line 48)
-    function test_isLimitOrder_notCoinBuy_returnsFalse() public {
+    function test_isLimitOrder_notCoinBuy_returnsFalse() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -577,7 +549,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when isCoinBuy is true (ensures we go past first condition)
-    function test_isLimitOrder_isCoinBuyTrue_checksOtherConditions() public {
+    function test_isLimitOrder_isCoinBuyTrue_checksOtherConditions() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](0); // Empty - no orders
         params.percentages = new uint256[](0);
@@ -590,7 +562,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when no orders in params
-    function test_isLimitOrder_noOrders_returnsFalse() public {
+    function test_isLimitOrder_noOrders_returnsFalse() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](0);
         params.percentages = new uint256[](0);
@@ -604,7 +576,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when swapper is zero address
-    function test_isLimitOrder_zeroSwapper_returnsFalse() public {
+    function test_isLimitOrder_zeroSwapper_returnsFalse() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -617,7 +589,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when coinDelta is negative
-    function test_isLimitOrder_negativeCoinDelta_returnsFalse() public {
+    function test_isLimitOrder_negativeCoinDelta_returnsFalse() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -630,7 +602,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when coinDelta is zero
-    function test_isLimitOrder_zeroCoinDelta_returnsFalse() public {
+    function test_isLimitOrder_zeroCoinDelta_returnsFalse() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -643,7 +615,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder accepts any positive coinDelta
-    function test_isLimitOrder_smallSize_returnsTrue() public {
+    function test_isLimitOrder_smallSize_returnsTrue() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -656,7 +628,7 @@ contract SwapLimitOrdersUnitTest is Test {
     }
 
     /// @notice Tests isLimitOrder when all conditions are met (success case)
-    function test_isLimitOrder_allConditionsMet_returnsTrue() public {
+    function test_isLimitOrder_allConditionsMet_returnsTrue() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -672,7 +644,7 @@ contract SwapLimitOrdersUnitTest is Test {
 
     /// @notice Tests computeOrders with misaligned baseTick produces aligned output ticks
     /// @dev This test verifies the fix for MKT-24: tick misalignment in minAway calculation
-    function test_computeOrders_misalignedBaseTick_producesValidTicks() public {
+    function test_computeOrders_misalignedBaseTick_producesValidTicks() public pure {
         // Use a pool with tickSpacing = 10 for easier verification
         PoolKey memory smallSpacingKey = PoolKey({
             currency0: Currency.wrap(address(0x1000)),
@@ -807,61 +779,50 @@ contract SwapLimitOrdersUnitTest is Test {
         assertGe(orders4.ticks[0], baseTick4 + 10, "aligned case 4: tick should be >= baseTick + spacing");
     }
 
-    /// @notice Tests fix for MKT-35: skip orders when baseTick at maxTick
-    /// @dev Uses baseTick at maxTick to simulate swap exhausting liquidity
-    function test_computeOrders_baseTickAtMaxTick_skipsOrders() public view {
+    /// @notice Test skip orders when price hits max boundary
+    function test_computeOrders_priceAtMax_sentinel_skipsOrders() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
         params.multiples[0] = 2 * MULTIPLE_SCALE;
         params.percentages[0] = 10000;
 
+        PoolKey memory key = testKey;
+        key.tickSpacing = 1;
+
         uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
-        int24 maxTick = TickMath.maxUsableTick(TICK_SPACING);
-        int24 baseTick = maxTick;
-        // Use MAX_SQRT_PRICE directly since we can't compute sqrt price at maxTick
         uint160 sqrtPriceX96 = TickMath.MAX_SQRT_PRICE - 1;
+        int24 baseTick = TickMath.getTickAtSqrtPrice(sqrtPriceX96);
+        int24 maxTick = TickMath.maxUsableTick(key.tickSpacing);
+        assertLe(baseTick, maxTick, "sanity: tick at/below max");
 
         // For currency0 (buy orders), should skip and return all as unallocated
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            totalSize,
-            baseTick,
-            sqrtPriceX96,
-            params
-        );
+        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(key, true, totalSize, baseTick, sqrtPriceX96, params);
 
         assertEq(orders.sizes.length, 0, "should create no orders");
         assertEq(allocated, 0, "should not allocate any funds");
         assertEq(unallocated, totalSize, "all funds should be unallocated");
     }
 
-    /// @notice Tests fix for MKT-35: skip orders when baseTick at minTick
-    /// @dev Uses baseTick at minTick to simulate swap exhausting liquidity
-    function test_computeOrders_baseTickAtMinTick_skipsOrders() public view {
+    /// @notice Test skip orders when price hits min boundary
+    function test_computeOrders_priceAtMin_sentinel_skipsOrders() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
         params.multiples[0] = 2 * MULTIPLE_SCALE;
         params.percentages[0] = 10000;
 
+        PoolKey memory key = testKey;
+        key.tickSpacing = 1;
+
         uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
-        int24 maxTick = TickMath.maxUsableTick(TICK_SPACING);
-        int24 minTick = -maxTick;
-        int24 baseTick = minTick;
-        // Use MIN_SQRT_PRICE directly since we can't compute sqrt price at minTick
         uint160 sqrtPriceX96 = TickMath.MIN_SQRT_PRICE + 1;
+        int24 baseTick = TickMath.getTickAtSqrtPrice(sqrtPriceX96);
+        int24 maxTick = TickMath.maxUsableTick(key.tickSpacing);
+        assertGe(baseTick, -maxTick, "sanity: tick at/above min");
 
         // For currency1 (sell orders), should skip and return all as unallocated
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            false,
-            totalSize,
-            baseTick,
-            sqrtPriceX96,
-            params
-        );
+        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(key, false, totalSize, baseTick, sqrtPriceX96, params);
 
         assertEq(orders.sizes.length, 0, "should create no orders");
         assertEq(allocated, 0, "should not allocate any funds");

package/test/unit/SwapLimitOrdersValidation.t.sol

@@ -220,14 +220,7 @@ contract SwapLimitOrdersValidationTest is Test {
         // Use exactly MIN size which is 1e18
         uint128 totalSize = uint128(TEST_ORDER_SIZE);
 
-        (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            uint128(totalSize),
-            0,
-            TickMath.getSqrtPriceAtTick(0),
-            params
-        );
+        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(testKey, true, uint128(totalSize), 0, TickMath.getSqrtPriceAtTick(0), params);
 
         // With TEST_ORDER_SIZE (1e18) and 1bp = 1e14, orders should not be skipped
         // Let's just verify we get at least one order
@@ -266,7 +259,6 @@ contract SwapLimitOrdersValidationTest is Test {
         params.multiples[0] = 1000000e18;
         params.percentages[0] = 10000;
 
-        int24 minTick = -TickMath.maxUsableTick(TICK_SPACING);
         int24 startTick = TickMath.MAX_TICK - 1000;
 
         (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
@@ -386,7 +378,7 @@ contract SwapLimitOrdersValidationTest is Test {
         // Test 3 & 4: minAway enforcement tested in previous minimum separation tests
     }
 
-    function _createValidParams(address maker, uint256 numOrders) internal pure returns (LimitOrderConfig memory) {
+    function _createValidParams(address /* maker */, uint256 numOrders) internal pure returns (LimitOrderConfig memory) {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](numOrders);
         params.percentages = new uint256[](numOrders);
@@ -400,7 +392,7 @@ contract SwapLimitOrdersValidationTest is Test {
         return params;
     }
 
-    function _createEmptyParams(address maker) internal pure returns (LimitOrderConfig memory) {
+    function _createEmptyParams(address /* maker */) internal pure returns (LimitOrderConfig memory) {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](0);
         params.percentages = new uint256[](0);

package/test/utils/BaseTest.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.13;
 
 import {Vm} from "forge-std/Vm.sol";
 import {V4TestSetup} from "@zoralabs/coins/test/utils/V4TestSetup.sol";
-import {IZoraLimitOrderBook} from "../../src/IZoraLimitOrderBook.sol";
 import {TestableZoraLimitOrderBook} from "./TestableZoraLimitOrderBook.sol";
 import {SwapWithLimitOrders} from "../../src/router/SwapWithLimitOrders.sol";
 import {IMsgSender} from "@zoralabs/coins/src/interfaces/IMsgSender.sol";
@@ -548,6 +547,7 @@ contract BaseTest is V4TestSetup, IMsgSender {
         int24 compressed = tick / tickSpacing;
         (int16 wordPos, uint8 bitPos) = TickBitmap.position(compressed);
         uint256 word = _bitmapWord(poolKeyHash, coin, wordPos);
+        // forge-lint-ignore incorrect-shift
         return (word & (1 << bitPos)) != 0;
     }