@zoralabs/limit-orders 0.2.0 → 0.2.2

package/test/SwapWithLimitOrdersRouter.t.sol

@@ -237,10 +237,10 @@ contract SwapWithLimitOrdersTestNonForked is SwapWithLimitOrdersTestBase {
         // TODO: Test unallocated coin handling
     }
 
-    function test_limitOrderPlacement_respectsMinSize() public {
-        // Test that small purchases below MIN_LIMIT_ORDER_SIZE don't create orders
+    function test_limitOrderPlacement_zeroSize() public {
+        // Test that zero-size purchases don't create orders
         // Should still execute swap but skip limit order ladder creation
-        // TODO: Test MIN_LIMIT_ORDER_SIZE threshold
+        // TODO: Test zero size handling
     }
 
     function test_limitOrderPlacement_supportsMultipleOrders() public {
@@ -307,9 +307,72 @@ contract SwapWithLimitOrdersTestNonForked is SwapWithLimitOrdersTestBase {
     }
 
     function test_orderFilling_invertedDirection() public {
-        // Verify fill direction is inverted (!isCoinCurrency0)
-        // Check correct orders are targeted for filling
-        // TODO: Requires verifying fill direction logic
+        // This test verifies the fix for audit issue #16
+        // https://github.com/kadenzipfel/zora-autosell-audit/issues/16
+        // The router should pass isCoinCurrency0 (not !isCoinCurrency0) to _fillOrders
+
+        PoolKey memory key = creatorCoin.getPoolKey();
+
+        // 1. Create first buyer's orders using swapWithLimitOrders
+        LimitOrderConfig memory limitOrderConfig = _prepareLimitOrderParams(users.buyer, _defaultMultiples(), _defaultPercentages());
+        deal(address(zoraToken), users.buyer, DEFAULT_LIMIT_ORDER_AMOUNT);
+
+        SwapWithLimitOrders.SwapWithLimitOrdersParams memory params = _buildDirectV4SwapParams(
+            users.buyer,
+            address(zoraToken),
+            DEFAULT_LIMIT_ORDER_AMOUNT,
+            key,
+            limitOrderConfig
+        );
+
+        vm.recordLogs();
+        _executeSwapWithLimitOrders(users.buyer, params);
+        CreatedOrderLog[] memory created = _decodeCreatedLogs(vm.getRecordedLogs());
+        assertGt(created.length, 0, "expected orders to be created");
+
+        // Store initial order state
+        address orderCoin = created[0].coin;
+        uint256 initialMakerBalance = _makerBalance(users.buyer, orderCoin);
+        assertGt(initialMakerBalance, 0, "buyer should have orders");
+
+        // 2. Mock the hook to not support ISupportsLimitOrderFill so router handles fills
+        bytes memory callData = abi.encodeWithSelector(IERC165.supportsInterface.selector, type(ISupportsLimitOrderFill).interfaceId);
+        vm.mockCall(address(key.hooks), callData, abi.encode(false));
+
+        // 3. Execute second swap that moves price beyond first orders AND creates new orders
+        // This ensures orders.length > 0 (from new orders) and tick moves past first orders
+        // Using a much larger swap to ensure we cross the first order ticks
+        LimitOrderConfig memory limitOrderConfig2 = _prepareLimitOrderParams(users.seller, _defaultMultiples(), _defaultPercentages());
+        uint256 largerSwapAmount = DEFAULT_LIMIT_ORDER_AMOUNT * 100; // 100x larger to move price significantly
+        deal(address(zoraToken), users.seller, largerSwapAmount);
+
+        SwapWithLimitOrders.SwapWithLimitOrdersParams memory params2 = _buildDirectV4SwapParams(
+            users.seller,
+            address(zoraToken),
+            largerSwapAmount,
+            key,
+            limitOrderConfig2
+        );
+
+        vm.recordLogs();
+        _executeSwapWithLimitOrders(users.seller, params2);
+
+        // 5. Verify fills occurred by checking FilledOrderLog events
+        FilledOrderLog[] memory fills = _decodeFilledLogs(vm.getRecordedLogs());
+
+        // The bug: with !isCoinCurrency0, fills won't happen because wrong direction
+        // After fix: fills SHOULD happen
+        assertGt(fills.length, 0, "orders should have been filled by router");
+
+        // 6. Verify orders were filled for correct maker
+        for (uint256 i = 0; i < fills.length; i++) {
+            assertEq(fills[i].maker, users.buyer, "incorrect maker");
+            assertEq(fills[i].coinIn, orderCoin, "incorrect coin");
+        }
+
+        // 7. Verify maker balance decreased (orders filled and paid out)
+        uint256 finalMakerBalance = _makerBalance(users.buyer, orderCoin);
+        assertLt(finalMakerBalance, initialMakerBalance, "maker balance should decrease after fills");
     }
 
     function test_reverts_emptyV4Route() public {
@@ -485,7 +548,6 @@ contract SwapWithLimitOrdersTestNonForked is SwapWithLimitOrdersTestBase {
         LimitOrderConfig memory limitOrderConfig = _prepareLimitOrderParams(users.buyer, _defaultMultiples(), _defaultPercentages());
 
         uint256 previousMax = limitOrderBook.getMaxFillCount();
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(0);
 
         bytes memory callData = abi.encodeWithSelector(IERC165.supportsInterface.selector, type(ISupportsLimitOrderFill).interfaceId);
@@ -508,7 +570,6 @@ contract SwapWithLimitOrdersTestNonForked is SwapWithLimitOrdersTestBase {
         assertEq(ordersFilled, 0, "max fill count zero should short-circuit fills");
 
         vm.clearMockedCalls();
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(previousMax);
     }
 
@@ -586,13 +647,14 @@ contract SwapWithLimitOrdersTestNonForked is SwapWithLimitOrdersTestBase {
                 address recipient = address(uint160(uint256(log.topics[2])));
                 assertEq(sender, users.buyer, "sender indexed mismatch");
                 assertEq(recipient, users.buyer, "recipient indexed mismatch");
-                (PoolKey memory loggedPoolKey, int256 delta, , , CreatedOrder[] memory orders) = abi.decode(
+                (PoolKey memory loggedPoolKey, , , int128 amount0, int128 amount1, uint160 sqrtPriceX96, CreatedOrder[] memory orders) = abi.decode(
                     log.data,
-                    (PoolKey, int256, int24, int24, CreatedOrder[])
+                    (PoolKey, int24, int24, int128, int128, uint160, CreatedOrder[])
                 );
                 assertEq(Currency.unwrap(loggedPoolKey.currency0), Currency.unwrap(poolKey.currency0), "pool currency0 mismatch");
                 assertEq(Currency.unwrap(loggedPoolKey.currency1), Currency.unwrap(poolKey.currency1), "pool currency1 mismatch");
-                assertEq(delta, 0, "returned delta should be zero");
+                assertTrue(amount0 != 0 || amount1 != 0, "swap amounts should be non-zero");
+                assertGt(sqrtPriceX96, 0, "sqrtPriceX96 should be non-zero");
                 assertGt(orders.length, 0, "should have created orders");
                 sawExecuted = true;
             }
@@ -645,8 +707,41 @@ contract SwapWithLimitOrdersTestNonForked is SwapWithLimitOrdersTestBase {
     }
 
     function test_event_SwapWithLimitOrdersExecuted() public {
-        // Verify SwapWithLimitOrdersExecuted event emitted with correct params
-        // Check sender, recipient, poolKey, deltas, ticks, orderIds, ordersFilled
+        // Verify SwapWithLimitOrdersExecuted event emits price data fields
+        PoolKey memory poolKey = creatorCoin.getPoolKey();
+        LimitOrderConfig memory limitOrderConfig = _prepareLimitOrderParams(users.buyer, _defaultMultiples(), _defaultPercentages());
+
+        uint256 inputAmount = DEFAULT_LIMIT_ORDER_AMOUNT;
+        deal(address(zoraToken), users.buyer, inputAmount);
+
+        SwapWithLimitOrders.SwapWithLimitOrdersParams memory params = _buildDirectV4SwapParams(
+            users.buyer,
+            address(zoraToken),
+            inputAmount,
+            poolKey,
+            limitOrderConfig
+        );
+
+        vm.recordLogs();
+        _executeSwapWithLimitOrders(users.buyer, params);
+
+        SwapExecutedLog[] memory swaps = _decodeSwapExecutedLogs(vm.getRecordedLogs());
+        assertEq(swaps.length, 1, "expected single swap event");
+
+        // Verify price data fields are populated
+        SwapExecutedLog memory swap = swaps[0];
+        assertEq(swap.sender, users.buyer, "sender mismatch");
+        assertEq(swap.recipient, users.buyer, "recipient mismatch");
+
+        // amount0 and amount1 should be non-zero (one negative, one positive for a swap)
+        assertTrue(swap.amount0 != 0 || swap.amount1 != 0, "swap amounts should be non-zero");
+        assertTrue((swap.amount0 < 0 && swap.amount1 > 0) || (swap.amount0 > 0 && swap.amount1 < 0), "amounts should have opposite signs for a swap");
+
+        // sqrtPriceX96 should be a valid price (non-zero, reasonable range)
+        assertGt(swap.sqrtPriceX96, 0, "sqrtPriceX96 should be non-zero");
+
+        // Tick movement should be reflected
+        assertTrue(swap.tickBefore != swap.tickAfter || swap.amount0 == 0, "tick should move on swap");
     }
 
     function test_event_LimitOrdersCreated() public {

package/test/gas/LimitOrderFillGas.t.sol

@@ -604,7 +604,6 @@ contract LimitOrderFillGasTest is BaseTest {
     /// @dev Tests well beyond recommended maxFillCount to validate safety margins
     function test_gas_user_swap_autofill_75_orders() public {
         // Increase maxFillCount for this test
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(100);
 
         PoolKey memory contentKey = contentCoin.getPoolKey();
@@ -647,7 +646,6 @@ contract LimitOrderFillGasTest is BaseTest {
     /// @dev Tests maximum scaling to identify absolute upper limits
     function test_gas_user_swap_autofill_100_orders() public {
         // Increase maxFillCount for this test
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(100);
 
         PoolKey memory contentKey = contentCoin.getPoolKey();
@@ -690,7 +688,6 @@ contract LimitOrderFillGasTest is BaseTest {
     /// @dev Tests backend/bot operations - isolated fill() call without user swap overhead
     function test_gas_backend_manual_fill_50_orders() public {
         // Increase maxFillCount for this test
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(100);
 
         PoolKey memory contentKey = contentCoin.getPoolKey();
@@ -738,7 +735,6 @@ contract LimitOrderFillGasTest is BaseTest {
     /// @dev Tests large backend batch operations
     function test_gas_backend_manual_fill_100_orders() public {
         // Increase maxFillCount for this test
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(100);
 
         PoolKey memory contentKey = contentCoin.getPoolKey();
@@ -786,7 +782,6 @@ contract LimitOrderFillGasTest is BaseTest {
     /// @dev Tests extreme backend batch - likely exceeds reasonable block gas limits
     function test_gas_backend_manual_fill_150_orders() public {
         // Increase maxFillCount for this test
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(200);
 
         PoolKey memory contentKey = contentCoin.getPoolKey();
@@ -853,12 +848,10 @@ contract LimitOrderFillGasTest is BaseTest {
     /// @dev Disables hook's auto-fill, executes swap, re-enables auto-fill
     function _movePriceBeyondTicksWithAutoFillDisabled(CreatedOrderLog[] memory created) internal override {
         uint256 previousMaxFillCount = limitOrderBook.getMaxFillCount();
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(0);
 
         _movePriceBeyondTicks(created);
 
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(previousMaxFillCount);
     }
 

package/test/gas/LimitOrderSwapGas.t.sol

@@ -107,7 +107,6 @@ contract LimitOrderSwapGasTest is BaseTest {
         CreatedOrderLog[] memory preloaded = existingOrders > 0 ? _preloadOrders(creatorKey, isCurrency0, existingOrders) : new CreatedOrderLog[](0);
         emit log_named_uint("PRELOADED_ORDERS", preloaded.length);
 
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(existingOrders + 10);
 
         PoolKey[] memory v4Route = new PoolKey[](1);
@@ -152,7 +151,6 @@ contract LimitOrderSwapGasTest is BaseTest {
         emit log_named_uint("PRELOADED_ORDERS", preloaded.length);
 
         // allow enough fills (existing + some headroom for newly in-range orders)
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(existingOrders + 10);
 
         // build router params (hop2: ZORA -> creator -> content)
@@ -198,7 +196,6 @@ contract LimitOrderSwapGasTest is BaseTest {
         CreatedOrderLog[] memory preloaded = existingOrders > 0 ? _preloadOrders(contentKey, isCurrency0, existingOrders) : new CreatedOrderLog[](0);
         emit log_named_uint("PRELOADED_ORDERS", preloaded.length);
 
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(existingOrders + 10);
 
         PoolKey[] memory v4Route = new PoolKey[](2);
@@ -243,7 +240,6 @@ contract LimitOrderSwapGasTest is BaseTest {
         CreatedOrderLog[] memory preloaded = existingOrders > 0 ? _preloadOrders(contentKey, isCurrency0, existingOrders) : new CreatedOrderLog[](0);
         emit log_named_uint("PRELOADED_ORDERS", preloaded.length);
 
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(existingOrders + 10);
 
         PoolKey[] memory v4Route = new PoolKey[](2);
@@ -285,7 +281,6 @@ contract LimitOrderSwapGasTest is BaseTest {
         PoolKey memory creatorKey = creatorCoin.getPoolKey();
         bool isCurrency0 = Currency.unwrap(creatorKey.currency0) == address(creatorCoin);
 
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(10);
 
         PoolKey[] memory v4Route = new PoolKey[](1);
@@ -326,7 +321,6 @@ contract LimitOrderSwapGasTest is BaseTest {
         PoolKey memory creatorKey = creatorCoin.getPoolKey();
         bool isCurrency0 = Currency.unwrap(creatorKey.currency0) == address(creatorCoin);
 
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(10);
 
         PoolKey[] memory v4Route = new PoolKey[](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");
+    }
 }