@zoralabs/limit-orders 0.2.0 → 0.2.1

package/test/unit/LimitOrderBitmapUnit.t.sol

@@ -82,140 +82,6 @@ contract LimitOrderBitmapUnitTest is Test {
         assertTrue(_isTickSet(tick), "bit should remain set when sizeAfter > 0");
     }
 
-    /// @notice Tests getExecutableTicks with zeroForOne = true (downward price movement)
-    function test_getExecutableTicks_zeroForOne_findsInitializedTicks() public {
-        // Set up ticks: 10000, 10200, 10400 (spaced by TICK_SPACING)
-        int24 tick1 = 10000;
-        int24 tick2 = 10200;
-        int24 tick3 = 10400;
-
-        LimitOrderBitmap.setIfFirst(bitmap, tick1, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick2, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick3, TICK_SPACING, 0);
-
-        // Set queue lengths to non-zero (simulates orders exist)
-        poolQueue[tick1].length = 1;
-        poolQueue[tick2].length = 1;
-        poolQueue[tick3].length = 1;
-
-        // Swap from 10800 down to 9800 (crosses all three ticks)
-        int24 tickBefore = 10800;
-        int24 tickAfter = 9800;
-        bool zeroForOne = true;
-
-        int24[] memory executableTicks = LimitOrderBitmap.getExecutableTicks(bitmap, poolQueue, TICK_SPACING, zeroForOne, tickBefore, tickAfter);
-
-        // Should find all 3 initialized ticks
-        assertEq(executableTicks.length, 3, "should find 3 executable ticks");
-        assertEq(executableTicks[0], tick3, "should find tick3 first (highest)");
-        assertEq(executableTicks[1], tick2, "should find tick2 second");
-        assertEq(executableTicks[2], tick1, "should find tick1 last (lowest)");
-    }
-
-    /// @notice Tests getExecutableTicks with zeroForOne = false (upward price movement)
-    function test_getExecutableTicks_oneForZero_findsInitializedTicks() public {
-        // Set up ticks: 5000, 5200, 5400
-        int24 tick1 = 5000;
-        int24 tick2 = 5200;
-        int24 tick3 = 5400;
-
-        LimitOrderBitmap.setIfFirst(bitmap, tick1, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick2, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick3, TICK_SPACING, 0);
-
-        poolQueue[tick1].length = 1;
-        poolQueue[tick2].length = 1;
-        poolQueue[tick3].length = 1;
-
-        // Swap from 4800 up to 5600 (crosses all three ticks)
-        int24 tickBefore = 4800;
-        int24 tickAfter = 5600;
-        bool zeroForOne = false;
-
-        int24[] memory executableTicks = LimitOrderBitmap.getExecutableTicks(bitmap, poolQueue, TICK_SPACING, zeroForOne, tickBefore, tickAfter);
-
-        // Should find all 3 initialized ticks in ascending order
-        assertEq(executableTicks.length, 3, "should find 3 executable ticks");
-        assertEq(executableTicks[0], tick1, "should find tick1 first (lowest)");
-        assertEq(executableTicks[1], tick2, "should find tick2 second");
-        assertEq(executableTicks[2], tick3, "should find tick3 last (highest)");
-    }
-
-    /// @notice Tests getExecutableTicks skips ticks with empty queues
-    function test_getExecutableTicks_skipsEmptyQueues() public {
-        // Set up 3 ticks, but only 2 have orders
-        int24 tick1 = 6000;
-        int24 tick2 = 6200; // This one will have empty queue
-        int24 tick3 = 6400;
-
-        LimitOrderBitmap.setIfFirst(bitmap, tick1, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick2, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick3, TICK_SPACING, 0);
-
-        poolQueue[tick1].length = 1;
-        poolQueue[tick2].length = 0; // Empty queue - should skip
-        poolQueue[tick3].length = 1;
-
-        int24 tickBefore = 6600;
-        int24 tickAfter = 5800;
-        bool zeroForOne = true;
-
-        int24[] memory executableTicks = LimitOrderBitmap.getExecutableTicks(bitmap, poolQueue, TICK_SPACING, zeroForOne, tickBefore, tickAfter);
-
-        // Should find only 2 ticks (skip tick2 with empty queue)
-        assertEq(executableTicks.length, 2, "should find only 2 executable ticks");
-        assertEq(executableTicks[0], tick3, "should find tick3");
-        assertEq(executableTicks[1], tick1, "should find tick1");
-        // tick2 should not be in the array
-    }
-
-    /// @notice Tests getExecutableTicks with no movement (tickBefore == tickAfter)
-    function test_getExecutableTicks_noMovement_returnsEmpty() public {
-        int24 tick = 7000;
-        LimitOrderBitmap.setIfFirst(bitmap, tick, TICK_SPACING, 0);
-        poolQueue[tick].length = 1;
-
-        int24 tickBefore = 7000;
-        int24 tickAfter = 7000; // No movement
-        bool zeroForOne = true;
-
-        int24[] memory executableTicks = LimitOrderBitmap.getExecutableTicks(bitmap, poolQueue, TICK_SPACING, zeroForOne, tickBefore, tickAfter);
-
-        // Should return empty array (no ticks crossed)
-        assertEq(executableTicks.length, 0, "should return empty array for no movement");
-    }
-
-    /// @notice Tests getExecutableTicks stops at target even if more ticks initialized beyond
-    function test_getExecutableTicks_stopsAtTarget() public {
-        // Set up ticks: 8000, 8200, 8400, 8600
-        int24 tick1 = 8000;
-        int24 tick2 = 8200;
-        int24 tick3 = 8400;
-        int24 tick4 = 8600;
-
-        LimitOrderBitmap.setIfFirst(bitmap, tick1, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick2, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick3, TICK_SPACING, 0);
-        LimitOrderBitmap.setIfFirst(bitmap, tick4, TICK_SPACING, 0);
-
-        poolQueue[tick1].length = 1;
-        poolQueue[tick2].length = 1;
-        poolQueue[tick3].length = 1;
-        poolQueue[tick4].length = 1;
-
-        // Swap only crosses tick4 and tick3, stops before tick2
-        int24 tickBefore = 8800;
-        int24 tickAfter = 8300; // Stops between tick3 and tick2
-        bool zeroForOne = true;
-
-        int24[] memory executableTicks = LimitOrderBitmap.getExecutableTicks(bitmap, poolQueue, TICK_SPACING, zeroForOne, tickBefore, tickAfter);
-
-        // Should find only tick4 and tick3 (stops at target)
-        assertEq(executableTicks.length, 2, "should find only 2 ticks before target");
-        assertEq(executableTicks[0], tick4, "should find tick4");
-        assertEq(executableTicks[1], tick3, "should find tick3");
-    }
-
     /// @notice Tests word boundaries (ticks at 256 * spacing intervals)
     function test_setIfFirst_wordBoundary() public {
         // Ticks at word boundaries

package/test/unit/LimitOrderCreateUnit.t.sol

@@ -73,6 +73,24 @@ contract LimitOrderCreateWrapper {
             refunded = requestedSize - realizedSize;
         }
     }
+
+    /// @notice Generates orderId using abi.encode (matches getOrderId)
+    function getOrderId(bytes32 poolKeyHash, address coin, int24 tick, address maker, uint256 nonce) external pure returns (bytes32) {
+        return keccak256(abi.encode(poolKeyHash, coin, tick, maker, nonce));
+    }
+
+    /// @notice Generates orderId using assembly (matches _generateOrderId in LimitOrderCreate.sol)
+    function generateOrderIdAssembly(bytes32 poolKeyHash, address coin, int24 orderTick, address maker, uint256 nonce) external pure returns (bytes32 orderId) {
+        assembly ("memory-safe") {
+            let ptr := mload(0x40)
+            mstore(ptr, poolKeyHash)
+            mstore(add(ptr, 0x20), coin)
+            mstore(add(ptr, 0x40), orderTick)
+            mstore(add(ptr, 0x60), maker)
+            mstore(add(ptr, 0x80), nonce)
+            orderId := keccak256(ptr, 0xa0)
+        }
+    }
 }
 
 /// @notice Direct unit tests for LimitOrderCreate library functions
@@ -355,4 +373,18 @@ contract LimitOrderCreateUnitTest is Test {
         uint128 realizedSize = wrapper.calculateRealizedSize(isCurrency0, amount0, amount1);
         assertEq(realizedSize, 1000000000, "should handle large negative value");
     }
+
+    /// @notice Verifies getOrderId and _generateOrderId produce identical hashes
+    function test_orderId_abiEncodeMatches() public view {
+        bytes32 poolKeyHash = keccak256("test-pool");
+        address coin = address(0x1234567890123456789012345678901234567890);
+        int24 tick = -12345;
+        address maker = address(0xabCDeF0123456789AbcdEf0123456789aBCDEF01);
+        uint256 nonce = 42;
+
+        bytes32 fromAbiEncode = wrapper.getOrderId(poolKeyHash, coin, tick, maker, nonce);
+        bytes32 fromAssembly = wrapper.generateOrderIdAssembly(poolKeyHash, coin, tick, maker, nonce);
+
+        assertEq(fromAbiEncode, fromAssembly, "orderId derivation must match");
+    }
 }

package/test/unit/SwapLimitOrdersUnit.t.sol

@@ -32,8 +32,8 @@ contract SwapLimitOrdersWrapper {
             return false;
         }
 
-        // Must be positive and above minimum threshold
-        return coinDelta > 0 && uint128(coinDelta) >= SwapLimitOrders.MIN_LIMIT_ORDER_SIZE;
+        // Must be positive
+        return coinDelta > 0;
     }
 }
 
@@ -44,7 +44,7 @@ contract SwapLimitOrdersUnitTest is Test {
     int24 constant TICK_SPACING = 200;
     uint256 constant MULTIPLE_SCALE = 1e18;
     uint256 constant PERCENT_SCALE = 10_000;
-    uint256 constant MIN_LIMIT_ORDER_SIZE = 1e18;
+    uint256 constant TEST_ORDER_SIZE = 1e18; // Convenient test size (1 token for 18-decimal)
 
     PoolKey internal testKey;
     SwapLimitOrdersWrapper internal wrapper;
@@ -202,8 +202,8 @@ contract SwapLimitOrdersUnitTest is Test {
         assertEq(totalPercent, 10000, "total percent should be 10000");
     }
 
-    /// @notice Tests computeOrders with totalSize below MIN_LIMIT_ORDER_SIZE (dust)
-    function test_computeOrders_belowMinSize_returnsEmpty() public {
+    /// @notice Tests computeOrders with totalSize of zero returns empty
+    function test_computeOrders_zeroSize_returnsEmpty() public {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -212,7 +212,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.percentages[0] = 5000;
         params.percentages[1] = 5000;
 
-        uint128 totalSize = uint128(MIN_LIMIT_ORDER_SIZE - 1); // Below minimum
+        uint128 totalSize = 0;
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -229,11 +229,11 @@ contract SwapLimitOrdersUnitTest is Test {
         assertEq(orders.sizes.length, 0, "sizes should be empty");
         assertEq(orders.ticks.length, 0, "ticks should be empty");
         assertEq(allocated, 0, "allocated should be 0");
-        assertEq(unallocated, totalSize, "unallocated should equal totalSize");
+        assertEq(unallocated, 0, "unallocated should be 0");
     }
 
-    /// @notice Tests computeOrders with totalSize exactly at MIN_LIMIT_ORDER_SIZE
-    function test_computeOrders_exactlyMinSize_createsOrders() public {
+    /// @notice Tests computeOrders with small totalSize creates orders
+    function test_computeOrders_smallSize_createsOrders() public {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -242,7 +242,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.percentages[0] = 5000;
         params.percentages[1] = 5000;
 
-        uint128 totalSize = uint128(MIN_LIMIT_ORDER_SIZE); // Exactly at minimum
+        uint128 totalSize = uint128(TEST_ORDER_SIZE); // Exactly at minimum
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -262,7 +262,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 MIN_LIMIT_ORDER_SIZE=1e18 and PERCENT_SCALE=10000
+    /// @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 {
         LimitOrderConfig memory params;
@@ -273,7 +273,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.percentages[0] = 5000;
         params.percentages[1] = 5000;
 
-        uint128 totalSize = uint128(MIN_LIMIT_ORDER_SIZE * 10);
+        uint128 totalSize = uint128(TEST_ORDER_SIZE * 10);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -302,7 +302,7 @@ contract SwapLimitOrdersUnitTest is Test {
             params.percentages[i] = 1000; // 10% each (60% total)
         }
 
-        uint128 totalSize = uint128(MIN_LIMIT_ORDER_SIZE * 100);
+        uint128 totalSize = uint128(TEST_ORDER_SIZE * 100);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -328,7 +328,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = 2 * MULTIPLE_SCALE;
         params.percentages[0] = 10000;
 
-        uint128 totalSize = uint128(MIN_LIMIT_ORDER_SIZE * 10);
+        uint128 totalSize = uint128(TEST_ORDER_SIZE * 10);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -355,7 +355,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.percentages[0] = 6000; // 60%
         params.percentages[1] = 3000; // 30% (total 90%)
 
-        uint128 totalSize = uint128(1000 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(1000 * TEST_ORDER_SIZE);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -392,7 +392,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.percentages[1] = 2000; // 20% of remaining
         params.percentages[2] = 2000; // 20% of remaining
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE); // 100 units for easy math
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE); // 100 units for easy math
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -430,7 +430,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = 1000 * MULTIPLE_SCALE; // 1000x - extremely high
         params.percentages[0] = 10000; // 100%
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -453,7 +453,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.percentages[0] = 5000;
         params.percentages[1] = 5000;
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         int24 baseTick = 10000;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -474,7 +474,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = 1000000 * MULTIPLE_SCALE; // 1,000,000x
         params.percentages[0] = 10000;
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         // Use moderate base tick (TickMath has max/min around ±887272)
         int24 baseTick = 100000; // Moderate positive tick
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
@@ -494,7 +494,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = 2 * MULTIPLE_SCALE;
         params.percentages[0] = 10000;
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         // Use moderate negative base tick for currency1
         int24 baseTick = -100000; // Moderate negative tick
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
@@ -515,7 +515,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = MULTIPLE_SCALE + (MULTIPLE_SCALE / 100); // 1.01x
         params.percentages[0] = 10000;
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -534,7 +534,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = MULTIPLE_SCALE + (MULTIPLE_SCALE / 100); // 1.01x
         params.percentages[0] = 10000;
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -553,7 +553,7 @@ contract SwapLimitOrdersUnitTest is Test {
         params.multiples[0] = 0; // Zero multiple - should revert in _sqrtMultiple
         params.percentages[0] = 10000;
 
-        uint128 totalSize = uint128(100 * MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
         int24 baseTick = 0;
         uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
 
@@ -571,7 +571,7 @@ contract SwapLimitOrdersUnitTest is Test {
 
         bool isCoinBuy = false; // NOT isCoinBuy - tests first branch
         address swapper = address(0x1234);
-        int128 coinDelta = int128(int256(MIN_LIMIT_ORDER_SIZE * 2));
+        int128 coinDelta = int128(int256(TEST_ORDER_SIZE * 2));
 
         assertFalse(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return false when not coin buy");
     }
@@ -584,7 +584,7 @@ contract SwapLimitOrdersUnitTest is Test {
 
         bool isCoinBuy = true; // Pass first condition
         address swapper = address(0x1234);
-        int128 coinDelta = int128(int256(MIN_LIMIT_ORDER_SIZE * 2));
+        int128 coinDelta = int128(int256(TEST_ORDER_SIZE * 2));
 
         assertFalse(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return false when no orders");
     }
@@ -597,8 +597,8 @@ contract SwapLimitOrdersUnitTest is Test {
 
         bool isCoinBuy = true;
         address swapper = address(0x1234);
-        // casting to 'int256' is safe because MIN_LIMIT_ORDER_SIZE will not overflow int128
-        int128 coinDelta = int128(int256(MIN_LIMIT_ORDER_SIZE * 2));
+        // casting to 'int256' is safe because TEST_ORDER_SIZE will not overflow int128
+        int128 coinDelta = int128(int256(TEST_ORDER_SIZE * 2));
 
         assertFalse(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return false when no orders");
     }
@@ -611,7 +611,7 @@ contract SwapLimitOrdersUnitTest is Test {
 
         bool isCoinBuy = true;
         address swapper = address(0); // Zero address
-        int128 coinDelta = int128(int256(MIN_LIMIT_ORDER_SIZE * 2));
+        int128 coinDelta = int128(int256(TEST_ORDER_SIZE * 2));
 
         assertFalse(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return false when swapper is zero");
     }
@@ -642,17 +642,17 @@ contract SwapLimitOrdersUnitTest is Test {
         assertFalse(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return false for zero delta");
     }
 
-    /// @notice Tests isLimitOrder when coinDelta below MIN_LIMIT_ORDER_SIZE (dust)
-    function test_isLimitOrder_belowMinSize_returnsFalse() public {
+    /// @notice Tests isLimitOrder accepts any positive coinDelta
+    function test_isLimitOrder_smallSize_returnsTrue() public {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
 
         bool isCoinBuy = true;
         address swapper = address(0x1234);
-        int128 coinDelta = int128(int256(MIN_LIMIT_ORDER_SIZE - 1)); // Below minimum
+        int128 coinDelta = 1; // Small positive amount
 
-        assertFalse(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return false when below min size");
+        assertTrue(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return true for any positive amount");
     }
 
     /// @notice Tests isLimitOrder when all conditions are met (success case)
@@ -665,8 +665,206 @@ contract SwapLimitOrdersUnitTest is Test {
 
         bool isCoinBuy = true;
         address swapper = address(0x1234);
-        int128 coinDelta = int128(int256(MIN_LIMIT_ORDER_SIZE * 2));
+        int128 coinDelta = int128(int256(TEST_ORDER_SIZE * 2));
 
         assertTrue(wrapper.isLimitOrder(isCoinBuy, swapper, coinDelta, params), "should return true when all conditions met");
     }
+
+    /// @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 {
+        // Use a pool with tickSpacing = 10 for easier verification
+        PoolKey memory smallSpacingKey = PoolKey({
+            currency0: Currency.wrap(address(0x1000)),
+            currency1: Currency.wrap(address(0x2000)),
+            fee: 3000,
+            tickSpacing: 10, // Small tick spacing to make misalignment easier to reproduce
+            hooks: IHooks(address(0))
+        });
+
+        LimitOrderConfig memory params;
+        params.multiples = new uint256[](1);
+        params.percentages = new uint256[](1);
+        // Use small multiple that would normally produce tick close to base
+        params.multiples[0] = MULTIPLE_SCALE + (MULTIPLE_SCALE / 100); // 1.01x
+        params.percentages[0] = 10000;
+
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
+
+        // Use a baseTick that is NOT aligned to tickSpacing=10
+        int24 baseTick = 205; // Not divisible by 10 - misaligned
+        uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(baseTick);
+
+        // Test for currency0 (buy orders, tick should be >= baseTick + tickSpacing)
+        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
+            smallSpacingKey,
+            true, // isCurrency0
+            totalSize,
+            baseTick,
+            sqrtPriceX96,
+            params
+        );
+
+        // Verify the returned tick is aligned to tickSpacing
+        assertEq(orders.ticks[0] % 10, 0, "tick must be aligned to tick spacing of 10");
+
+        // Verify tick is at least one tickSpacing away from the aligned baseTick
+        // For currency0, baseTick=205 should align down to 200, so minAway=210
+        assertGe(orders.ticks[0], 210, "tick should be >= aligned baseTick (200) + spacing (10)");
+
+        // Test for currency1 (sell orders, tick should be <= baseTick - tickSpacing)
+        (Orders memory orders1, , ) = SwapLimitOrders.computeOrders(
+            smallSpacingKey,
+            false, // !isCurrency0
+            totalSize,
+            baseTick,
+            sqrtPriceX96,
+            params
+        );
+
+        // Verify the returned tick is aligned to tickSpacing
+        assertEq(orders1.ticks[0] % 10, 0, "tick must be aligned to tick spacing of 10");
+
+        // Verify tick is at least one tickSpacing away from the aligned baseTick
+        // For currency1, baseTick=205 should align up to 210, so minAway=200
+        assertLe(orders1.ticks[0], 200, "tick should be <= aligned baseTick (210) - spacing (10)");
+    }
+
+    /// @notice Tests computeOrders with various misaligned baseTicks and tick spacings
+    function test_computeOrders_variousMisalignments_allProduceValidTicks() public {
+        LimitOrderConfig memory params;
+        params.multiples = new uint256[](1);
+        params.percentages = new uint256[](1);
+        params.multiples[0] = MULTIPLE_SCALE + (MULTIPLE_SCALE / 50); // 1.02x
+        params.percentages[0] = 10000;
+
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
+
+        // Test case 1: baseTick=205, tickSpacing=10
+        PoolKey memory key10 = testKey;
+        key10.tickSpacing = 10;
+        int24 baseTick1 = 205;
+        uint160 sqrtPrice1 = TickMath.getSqrtPriceAtTick(baseTick1);
+        (Orders memory orders1, , ) = SwapLimitOrders.computeOrders(key10, true, totalSize, baseTick1, sqrtPrice1, params);
+        assertEq(orders1.ticks[0] % 10, 0, "case 1: tick must be aligned to spacing 10");
+
+        // Test case 2: baseTick=1505, tickSpacing=200
+        PoolKey memory key200 = testKey;
+        key200.tickSpacing = 200;
+        int24 baseTick2 = 1505;
+        uint160 sqrtPrice2 = TickMath.getSqrtPriceAtTick(baseTick2);
+        (Orders memory orders2, , ) = SwapLimitOrders.computeOrders(key200, true, totalSize, baseTick2, sqrtPrice2, params);
+        assertEq(orders2.ticks[0] % 200, 0, "case 2: tick must be aligned to spacing 200");
+
+        // Test case 3: negative misaligned baseTick=-95, tickSpacing=10
+        int24 baseTick3 = -95;
+        uint160 sqrtPrice3 = TickMath.getSqrtPriceAtTick(baseTick3);
+        (Orders memory orders3, , ) = SwapLimitOrders.computeOrders(key10, true, totalSize, baseTick3, sqrtPrice3, params);
+        assertEq(orders3.ticks[0] % 10, 0, "case 3: tick must be aligned to spacing 10");
+    }
+
+    /// @notice Tests computeOrders with already-aligned baseTicks remain aligned
+    /// @dev Verifies that the fix doesn't break the common case where baseTick is already aligned
+    function test_computeOrders_alignedBaseTick_remainsAligned() public {
+        LimitOrderConfig memory params;
+        params.multiples = new uint256[](1);
+        params.percentages = new uint256[](1);
+        params.multiples[0] = MULTIPLE_SCALE + (MULTIPLE_SCALE / 50); // 1.02x
+        params.percentages[0] = 10000;
+
+        uint128 totalSize = uint128(100 * TEST_ORDER_SIZE);
+
+        // Test case 1: baseTick=200 (aligned), tickSpacing=10
+        PoolKey memory key10 = testKey;
+        key10.tickSpacing = 10;
+        int24 baseTick1 = 200; // Already divisible by 10
+        uint160 sqrtPrice1 = TickMath.getSqrtPriceAtTick(baseTick1);
+        (Orders memory orders1, , ) = SwapLimitOrders.computeOrders(key10, true, totalSize, baseTick1, sqrtPrice1, params);
+        assertEq(orders1.ticks[0] % 10, 0, "aligned case 1: tick must be aligned to spacing 10");
+        assertGe(orders1.ticks[0], baseTick1 + 10, "aligned case 1: tick should be >= baseTick + spacing");
+
+        // Test case 2: baseTick=1400 (aligned), tickSpacing=200
+        PoolKey memory key200 = testKey;
+        key200.tickSpacing = 200;
+        int24 baseTick2 = 1400; // Already divisible by 200
+        uint160 sqrtPrice2 = TickMath.getSqrtPriceAtTick(baseTick2);
+        (Orders memory orders2, , ) = SwapLimitOrders.computeOrders(key200, true, totalSize, baseTick2, sqrtPrice2, params);
+        assertEq(orders2.ticks[0] % 200, 0, "aligned case 2: tick must be aligned to spacing 200");
+        assertGe(orders2.ticks[0], baseTick2 + 200, "aligned case 2: tick should be >= baseTick + spacing");
+
+        // Test case 3: baseTick=0 (aligned), tickSpacing=10
+        int24 baseTick3 = 0; // Already divisible by any spacing
+        uint160 sqrtPrice3 = TickMath.getSqrtPriceAtTick(baseTick3);
+        (Orders memory orders3, , ) = SwapLimitOrders.computeOrders(key10, true, totalSize, baseTick3, sqrtPrice3, params);
+        assertEq(orders3.ticks[0] % 10, 0, "aligned case 3: tick must be aligned to spacing 10");
+        assertGe(orders3.ticks[0], baseTick3 + 10, "aligned case 3: tick should be >= baseTick + spacing");
+
+        // Test case 4: negative aligned baseTick=-100, tickSpacing=10
+        int24 baseTick4 = -100; // Already divisible by 10
+        uint160 sqrtPrice4 = TickMath.getSqrtPriceAtTick(baseTick4);
+        (Orders memory orders4, , ) = SwapLimitOrders.computeOrders(key10, true, totalSize, baseTick4, sqrtPrice4, params);
+        assertEq(orders4.ticks[0] % 10, 0, "aligned case 4: tick must be aligned to spacing 10");
+        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 {
+        LimitOrderConfig memory params;
+        params.multiples = new uint256[](1);
+        params.percentages = new uint256[](1);
+        params.multiples[0] = 2 * MULTIPLE_SCALE;
+        params.percentages[0] = 10000;
+
+        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;
+
+        // 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
+        );
+
+        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 {
+        LimitOrderConfig memory params;
+        params.multiples = new uint256[](1);
+        params.percentages = new uint256[](1);
+        params.multiples[0] = 2 * MULTIPLE_SCALE;
+        params.percentages[0] = 10000;
+
+        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;
+
+        // 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
+        );
+
+        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");
+    }
 }