@zoralabs/limit-orders 0.2.0 → 0.2.2

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 view {
+        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 view {
+        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 view {
+        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 view {
+        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");
+    }
 }