@zoralabs/limit-orders 0.2.0 → 0.2.2

package/test/unit/SwapLimitOrdersValidation.t.sol

@@ -14,6 +14,7 @@ contract SwapLimitOrdersValidationTest is Test {
 
     PoolKey internal testKey;
     int24 constant TICK_SPACING = 10;
+    uint256 constant TEST_ORDER_SIZE = 1e18; // Convenient test size (1 token for 18-decimal)
     SwapLimitOrdersWrapper internal wrapper;
 
     function setUp() public {
@@ -36,7 +37,7 @@ contract SwapLimitOrdersValidationTest is Test {
         bool result = wrapper.isLimitOrder(
             false, // not a coin buy
             makeAddr("testSwapper"),
-            int128(uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE)),
+            int128(uint128(TEST_ORDER_SIZE)),
             params
         );
 
@@ -46,7 +47,7 @@ contract SwapLimitOrdersValidationTest is Test {
     function test_isLimitOrder_NoOrders() public {
         LimitOrderConfig memory params = _createEmptyParams(makeAddr("maker"));
 
-        bool result = wrapper.isLimitOrder(true, makeAddr("testSwapper"), int128(uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE)), params);
+        bool result = wrapper.isLimitOrder(true, makeAddr("testSwapper"), int128(uint128(TEST_ORDER_SIZE)), params);
 
         assertFalse(result, "should return false when no orders configured");
     }
@@ -57,7 +58,7 @@ contract SwapLimitOrdersValidationTest is Test {
         bool result = wrapper.isLimitOrder(
             true,
             address(0), // zero swapper
-            int128(uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE)),
+            int128(uint128(TEST_ORDER_SIZE)),
             params
         );
 
@@ -90,23 +91,23 @@ contract SwapLimitOrdersValidationTest is Test {
         assertFalse(result, "should return false for zero coinDelta");
     }
 
-    function test_isLimitOrder_BelowMinimumSize() public {
+    function test_isLimitOrder_SmallSize() public {
         LimitOrderConfig memory params = _createValidParams(makeAddr("maker"), 1);
 
         bool result = wrapper.isLimitOrder(
             true,
             makeAddr("testSwapper"),
-            int128(uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE - 1)), // dust amount
+            int128(1), // small amount
             params
         );
 
-        assertFalse(result, "should return false for dust amounts below minimum");
+        assertTrue(result, "should return true for any positive amount");
     }
 
     function test_isLimitOrder_ValidCase() public {
         LimitOrderConfig memory params = _createValidParams(makeAddr("maker"), 1);
 
-        bool result = wrapper.isLimitOrder(true, makeAddr("testSwapper"), int128(uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE)), params);
+        bool result = wrapper.isLimitOrder(true, makeAddr("testSwapper"), int128(uint128(TEST_ORDER_SIZE)), params);
 
         assertTrue(result, "should return true when all conditions met");
     }
@@ -166,7 +167,7 @@ contract SwapLimitOrdersValidationTest is Test {
         wrapper.validate(params);
     }
 
-    function test_validate_UnderOneHundredPercent() public {
+    function test_validate_UnderOneHundredPercent() public pure {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](2);
         params.percentages = new uint256[](2);
@@ -180,14 +181,13 @@ contract SwapLimitOrdersValidationTest is Test {
         assertEq(totalPercent, 8000, "should allow undershoot");
     }
 
-    function test_computeOrders_BelowMinimum() public {
+    function test_computeOrders_ZeroSize() public {
         LimitOrderConfig memory params = _createValidParams(makeAddr("maker"), 2);
-        uint128 dustSize = uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE - 1);
 
         (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
             testKey,
             true, // isCurrency0
-            uint128(dustSize),
+            0, // zero size
             0, // baseTick
             TickMath.getSqrtPriceAtTick(0),
             params
@@ -196,10 +196,10 @@ contract SwapLimitOrdersValidationTest is Test {
         assertEq(orders.sizes.length, 0, "should return empty orders");
         assertEq(orders.ticks.length, 0, "should return empty ticks");
         assertEq(allocated, 0, "should have zero allocated");
-        assertEq(unallocated, uint128(dustSize), "all should be unallocated");
+        assertEq(unallocated, 0, "unallocated should be zero");
     }
 
-    function test_computeOrders_SkipsZeroSizeOrders() public {
+    function test_computeOrders_SkipsZeroSizeOrders() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](4);
         params.percentages = new uint256[](4);
@@ -218,7 +218,7 @@ contract SwapLimitOrdersValidationTest is Test {
         params.percentages[3] = 1; // 0.01% - may round to zero with small size
 
         // Use exactly MIN size which is 1e18
-        uint128 totalSize = uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE);
+        uint128 totalSize = uint128(TEST_ORDER_SIZE);
 
         (Orders memory orders, uint128 allocated, uint128 unallocated) = SwapLimitOrders.computeOrders(
             testKey,
@@ -229,13 +229,13 @@ contract SwapLimitOrdersValidationTest is Test {
             params
         );
 
-        // With MIN_LIMIT_ORDER_SIZE (1e18) and 1bp = 1e14, orders should not be skipped
+        // With TEST_ORDER_SIZE (1e18) and 1bp = 1e14, orders should not be skipped
         // Let's just verify we get at least one order
         assertGt(orders.sizes.length, 0, "should create at least one order");
         assertEq(orders.sizes.length, orders.ticks.length, "sizes and ticks should match");
     }
 
-    function test_computeOrders_ClampsToMaxTick() public {
+    function test_computeOrders_ClampsToMaxTick() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -246,14 +246,7 @@ contract SwapLimitOrdersValidationTest is Test {
 
         int24 maxTick = TickMath.maxUsableTick(TICK_SPACING);
 
-        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
-            0,
-            TickMath.getSqrtPriceAtTick(0),
-            params
-        );
+        (Orders memory orders, , ) = SwapLimitOrders.computeOrders(testKey, true, uint128(TEST_ORDER_SIZE), 0, TickMath.getSqrtPriceAtTick(0), params);
 
         assertEq(orders.ticks.length, 1, "should create one order");
         // Should clamp to max usable tick - the function applies clamping logic
@@ -264,7 +257,7 @@ contract SwapLimitOrdersValidationTest is Test {
         assertGt(orders.ticks[0], 0, "should be positive tick for buy orders");
     }
 
-    function test_computeOrders_ClampsToMinTick() public {
+    function test_computeOrders_ClampsToMinTick() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -279,7 +272,7 @@ contract SwapLimitOrdersValidationTest is Test {
         (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
             testKey,
             false, // isCurrency0 = false means selling, inverts multiple
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
+            uint128(TEST_ORDER_SIZE),
             startTick,
             TickMath.getSqrtPriceAtTick(startTick),
             params
@@ -289,7 +282,7 @@ contract SwapLimitOrdersValidationTest is Test {
         assertLe(orders.ticks[0], TickMath.maxUsableTick(TICK_SPACING), "should be within valid range");
     }
 
-    function test_computeOrders_MinimumSeparationCurrency0() public {
+    function test_computeOrders_MinimumSeparationCurrency0() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -303,7 +296,7 @@ contract SwapLimitOrdersValidationTest is Test {
         (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
             testKey,
             true, // isCurrency0
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
+            uint128(TEST_ORDER_SIZE),
             baseTick,
             TickMath.getSqrtPriceAtTick(baseTick),
             params
@@ -314,7 +307,7 @@ contract SwapLimitOrdersValidationTest is Test {
         assertGe(orders.ticks[0], baseTick + TICK_SPACING, "should maintain minimum separation");
     }
 
-    function test_computeOrders_MinimumSeparationCurrency1() public {
+    function test_computeOrders_MinimumSeparationCurrency1() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -328,7 +321,7 @@ contract SwapLimitOrdersValidationTest is Test {
         (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
             testKey,
             false, // not isCurrency0
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
+            uint128(TEST_ORDER_SIZE),
             baseTick,
             TickMath.getSqrtPriceAtTick(baseTick),
             params
@@ -339,7 +332,7 @@ contract SwapLimitOrdersValidationTest is Test {
         assertLe(orders.ticks[0], baseTick - TICK_SPACING, "should maintain minimum separation");
     }
 
-    function test_computeOrders_MultiplierInversionForCurrency1() public {
+    function test_computeOrders_MultiplierInversionForCurrency1() public view {
         LimitOrderConfig memory params;
         params.multiples = new uint256[](1);
         params.percentages = new uint256[](1);
@@ -354,7 +347,7 @@ contract SwapLimitOrdersValidationTest is Test {
         (Orders memory orders, , ) = SwapLimitOrders.computeOrders(
             testKey,
             false, // not isCurrency0 - triggers inversion
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
+            uint128(TEST_ORDER_SIZE),
             baseTick,
             TickMath.getSqrtPriceAtTick(baseTick),
             params
@@ -365,7 +358,7 @@ contract SwapLimitOrdersValidationTest is Test {
         assertLt(orders.ticks[0], baseTick, "inverted multiplier should place tick below base");
     }
 
-    function test_computeOrders_AllBoundaryClampingBranches() public {
+    function test_computeOrders_AllBoundaryClampingBranches() public view {
         LimitOrderConfig memory params;
 
         // Test 1: aligned > maxTick (line 167)
@@ -374,14 +367,7 @@ contract SwapLimitOrdersValidationTest is Test {
         params.multiples[0] = 1000000e18;
         params.percentages[0] = 10000;
 
-        (Orders memory orders1, , ) = SwapLimitOrders.computeOrders(
-            testKey,
-            true,
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
-            0,
-            TickMath.getSqrtPriceAtTick(0),
-            params
-        );
+        (Orders memory orders1, , ) = SwapLimitOrders.computeOrders(testKey, true, uint128(TEST_ORDER_SIZE), 0, TickMath.getSqrtPriceAtTick(0), params);
         assertLe(orders1.ticks[0], TickMath.maxUsableTick(TICK_SPACING), "should clamp to maxTick");
 
         // Test 2: aligned < minTick (line 168)
@@ -390,7 +376,7 @@ contract SwapLimitOrdersValidationTest is Test {
         (Orders memory orders2, , ) = SwapLimitOrders.computeOrders(
             testKey,
             false, // inverted, goes negative
-            uint128(SwapLimitOrders.MIN_LIMIT_ORDER_SIZE),
+            uint128(TEST_ORDER_SIZE),
             veryHighTick,
             TickMath.getSqrtPriceAtTick(veryHighTick),
             params

package/test/unit/SwapWithLimitOrdersUnit.t.sol

@@ -14,24 +14,14 @@ contract SwapWithLimitOrdersLogicWrapper {
         return true; // Would proceed to fill
     }
 
-    /// @notice Tests tick ordering logic for currency0 (lines 403-406)
-    function orderTicks_currency0(int24 tickBeforeSwap, int24 tickAfterSwap) external pure returns (int24 startTick, int24 endTick) {
-        bool isCurrency0 = true;
-        if (isCurrency0) {
-            // Currency0 orders need ascending tick range
-            startTick = tickBeforeSwap < tickAfterSwap ? tickBeforeSwap : tickAfterSwap;
-            endTick = tickBeforeSwap < tickAfterSwap ? tickAfterSwap : tickBeforeSwap;
-        }
-    }
-
-    /// @notice Tests tick ordering logic for currency1 (lines 407-411)
-    function orderTicks_currency1(int24 tickBeforeSwap, int24 tickAfterSwap) external pure returns (int24 startTick, int24 endTick) {
-        bool isCurrency0 = false;
-        if (!isCurrency0) {
-            // Currency1 orders need descending tick range
-            startTick = tickBeforeSwap > tickAfterSwap ? tickBeforeSwap : tickAfterSwap;
-            endTick = tickBeforeSwap > tickAfterSwap ? tickAfterSwap : tickBeforeSwap;
+    /// @notice Tests _fillOrders direction derivation from tick movement
+    /// @return shouldFill Whether fill should proceed
+    /// @return isCurrency0 The derived fill direction
+    function deriveFillDirection(int24 tickBeforeSwap, int24 tickAfterSwap) external pure returns (bool shouldFill, bool isCurrency0) {
+        if (tickAfterSwap == tickBeforeSwap) {
+            return (false, false);
         }
+        return (true, tickAfterSwap > tickBeforeSwap);
     }
 
     /// @notice Tests settlement unallocated branch (line 356)
@@ -109,70 +99,24 @@ contract SwapWithLimitOrdersUnitTest is Test {
         assertTrue(shouldFill, "should fill when maxFillCount is 1");
     }
 
-    /// @notice Tests currency0 tick ordering when tickBefore < tickAfter (ascending)
-    function test_orderTicks_currency0_ascending() public view {
-        int24 tickBefore = 1000;
-        int24 tickAfter = 2000;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency0(tickBefore, tickAfter);
-
-        assertEq(startTick, 1000, "startTick should be tickBefore");
-        assertEq(endTick, 2000, "endTick should be tickAfter");
+    /// @notice Tests fill direction derivation: tick increase → currency0
+    function test_deriveFillDirection_tickIncreases_isCurrency0() public view {
+        (bool shouldFill, bool isCurrency0) = wrapper.deriveFillDirection(1000, 2000);
+        assertTrue(shouldFill, "should fill when tick moved");
+        assertTrue(isCurrency0, "tick increase = currency0 orders fillable");
     }
 
-    /// @notice Tests currency0 tick ordering when tickBefore > tickAfter (needs swap)
-    function test_orderTicks_currency0_descending_swaps() public view {
-        int24 tickBefore = 2000;
-        int24 tickAfter = 1000;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency0(tickBefore, tickAfter);
-
-        assertEq(startTick, 1000, "startTick should be minimum");
-        assertEq(endTick, 2000, "endTick should be maximum");
+    /// @notice Tests fill direction derivation: tick decrease → currency1
+    function test_deriveFillDirection_tickDecreases_isCurrency1() public view {
+        (bool shouldFill, bool isCurrency0) = wrapper.deriveFillDirection(2000, 1000);
+        assertTrue(shouldFill, "should fill when tick moved");
+        assertFalse(isCurrency0, "tick decrease = currency1 orders fillable");
     }
 
-    /// @notice Tests currency0 tick ordering when ticks are equal
-    function test_orderTicks_currency0_equal() public view {
-        int24 tickBefore = 1500;
-        int24 tickAfter = 1500;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency0(tickBefore, tickAfter);
-
-        assertEq(startTick, 1500, "startTick should equal tickBefore");
-        assertEq(endTick, 1500, "endTick should equal tickBefore");
-    }
-
-    /// @notice Tests currency1 tick ordering when tickBefore > tickAfter (descending)
-    function test_orderTicks_currency1_descending() public view {
-        int24 tickBefore = 2000;
-        int24 tickAfter = 1000;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency1(tickBefore, tickAfter);
-
-        assertEq(startTick, 2000, "startTick should be tickBefore");
-        assertEq(endTick, 1000, "endTick should be tickAfter");
-    }
-
-    /// @notice Tests currency1 tick ordering when tickBefore < tickAfter (needs swap)
-    function test_orderTicks_currency1_ascending_swaps() public view {
-        int24 tickBefore = 1000;
-        int24 tickAfter = 2000;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency1(tickBefore, tickAfter);
-
-        assertEq(startTick, 2000, "startTick should be maximum");
-        assertEq(endTick, 1000, "endTick should be minimum");
-    }
-
-    /// @notice Tests currency1 tick ordering with negative ticks
-    function test_orderTicks_currency1_negativeTicks() public view {
-        int24 tickBefore = -1000;
-        int24 tickAfter = -2000;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency1(tickBefore, tickAfter);
-
-        assertEq(startTick, -1000, "startTick should be -1000");
-        assertEq(endTick, -2000, "endTick should be -2000");
+    /// @notice Tests fill direction derivation: no movement → no fill
+    function test_deriveFillDirection_noMovement_noFill() public view {
+        (bool shouldFill, ) = wrapper.deriveFillDirection(1500, 1500);
+        assertFalse(shouldFill, "should not fill when tick unchanged");
     }
 
     /// @notice Tests that unallocated > 0 triggers take
@@ -302,17 +246,6 @@ contract SwapWithLimitOrdersUnitTest is Test {
         assertEq(result, "Valid");
     }
 
-    /// @notice Tests tick ordering with max int24 values
-    function test_orderTicks_maxValues() public view {
-        int24 maxTick = type(int24).max;
-        int24 minTick = type(int24).min;
-
-        (int24 startTick, int24 endTick) = wrapper.orderTicks_currency0(maxTick, minTick);
-
-        assertEq(startTick, minTick, "should handle max/min correctly");
-        assertEq(endTick, maxTick, "should handle max/min correctly");
-    }
-
     /// @notice Tests unallocated with max uint128 value
     function test_shouldTakeUnallocated_maxValue() public view {
         bool shouldTake = wrapper.shouldTakeUnallocated(type(uint128).max);

package/test/utils/BaseTest.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.13;
 
 import {Vm} from "forge-std/Vm.sol";
-import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
 import {V4TestSetup} from "@zoralabs/coins/test/utils/V4TestSetup.sol";
 import {IZoraLimitOrderBook} from "../../src/IZoraLimitOrderBook.sol";
 import {TestableZoraLimitOrderBook} from "./TestableZoraLimitOrderBook.sol";
@@ -26,6 +25,8 @@ import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
 import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol";
 import {AddressConstants} from "@zoralabs/coins/test/utils/hookmate/constants/AddressConstants.sol";
 import {ICoin} from "@zoralabs/coins/src/interfaces/ICoin.sol";
+import {IWETH} from "@zoralabs/coins/src/interfaces/IWETH.sol";
+import {MockWETH} from "./MockWETH.sol";
 
 /**
  * @title BaseTest
@@ -34,8 +35,8 @@ import {ICoin} from "@zoralabs/coins/src/interfaces/ICoin.sol";
  */
 contract BaseTest is V4TestSetup, IMsgSender {
     using PoolIdLibrary for PoolKey;
+
     TestableZoraLimitOrderBook internal limitOrderBook = TestableZoraLimitOrderBook(payable(makeAddr("limitOrderBook")));
-    AccessManager internal accessManager;
     SwapWithLimitOrders internal swapWithLimitOrders;
 
     function setUp() public virtual {
@@ -57,28 +58,26 @@ contract BaseTest is V4TestSetup, IMsgSender {
     }
 
     function _setupLimitOrderBook() internal {
-        // Deploy AccessManager with this contract as admin
-        accessManager = new AccessManager(address(this));
+        // Deploy WETH mock if not already set
+        if (address(weth) == address(0)) {
+            weth = IWETH(address(new MockWETH()));
+        }
 
+        // Deploy ZoraLimitOrderBook with this contract as owner
         deployCodeTo(
             "TestableZoraLimitOrderBook.sol:TestableZoraLimitOrderBook",
-            abi.encode(address(poolManager), address(factory), address(zoraHookRegistry), address(accessManager)),
+            abi.encode(address(poolManager), address(factory), address(zoraHookRegistry), address(this), address(weth)),
             address(limitOrderBook)
         );
-        require(limitOrderBook.authority() == address(accessManager), "ZoraLimitOrderBook authority is not the access manager");
-
-        // Set create() and setMaxFillCount() functions to PUBLIC_ROLE to allow anyone to call them initially
-        bytes4[] memory selectors = new bytes4[](2);
-        selectors[0] = IZoraLimitOrderBook.create.selector;
-        selectors[1] = IZoraLimitOrderBook.setMaxFillCount.selector;
-        accessManager.setTargetFunctionRole(address(limitOrderBook), selectors, accessManager.PUBLIC_ROLE());
+        require(limitOrderBook.owner() == address(this), "ZoraLimitOrderBook owner is not this contract");
 
         limitOrderBook.setMaxFillCount(50);
 
         vm.label(address(limitOrderBook), "LIMIT_ORDER_BOOK");
 
-        swapWithLimitOrders = new SwapWithLimitOrders(poolManager, limitOrderBook, swapRouter, AddressConstants.getPermit2Address());
+        swapWithLimitOrders = new SwapWithLimitOrders(poolManager, limitOrderBook, swapRouter, AddressConstants.getPermit2Address(), address(this));
         vm.label(address(swapWithLimitOrders), "SWAP_WITH_LIMIT_ORDERS");
+
         // Now create the real ZoraLimitOrderBook for tests that need it
         _deployTestCoins();
     }
@@ -96,7 +95,9 @@ contract BaseTest is V4TestSetup, IMsgSender {
         keccak256("LimitOrderFilled(address,address,address,uint128,uint128,address,uint128,bytes32,int24,bytes32)");
     bytes32 internal constant LIMIT_ORDER_UPDATED_TOPIC = keccak256("LimitOrderUpdated(address,address,bytes32,bool,int24,uint128,bytes32,bool)");
     bytes32 internal constant SWAP_WITH_LIMIT_ORDERS_EXECUTED_TOPIC =
-        keccak256("SwapWithLimitOrdersExecuted(address,address,(address,address,uint24,int24,address),int256,int24,int24,(bytes32,uint256,uint256)[])");
+        keccak256(
+            "SwapWithLimitOrdersExecuted(address,address,(address,address,uint24,int24,address),int24,int24,int128,int128,uint160,(bytes32,uint256,uint256)[])"
+        );
 
     struct QueueSnapshot {
         bytes32 head;
@@ -150,9 +151,11 @@ contract BaseTest is V4TestSetup, IMsgSender {
         address sender;
         address recipient;
         PoolKey poolKey;
-        int256 delta;
         int24 tickBefore;
         int24 tickAfter;
+        int128 amount0;
+        int128 amount1;
+        uint160 sqrtPriceX96;
         CreatedOrder[] orders;
     }
 
@@ -464,6 +467,10 @@ contract BaseTest is V4TestSetup, IMsgSender {
         return isCurrency0 ? baseTick + offset : baseTick - offset;
     }
 
+    function _fillableTick(bool isCurrency0, int24 orderTick, int24 spacing) internal pure returns (int24) {
+        return isCurrency0 ? orderTick + spacing : orderTick - spacing;
+    }
+
     function _buildDeterministicOrders(
         PoolKey memory key,
         bool isCurrency0,
@@ -667,18 +674,25 @@ contract BaseTest is V4TestSetup, IMsgSender {
             Vm.Log memory log = logs[i];
             if (log.topics.length == 0 || log.topics[0] != SWAP_WITH_LIMIT_ORDERS_EXECUTED_TOPIC) continue;
 
-            (PoolKey memory poolKey, int256 delta, int24 tickBefore, int24 tickAfter, CreatedOrder[] memory orders) = abi.decode(
-                log.data,
-                (PoolKey, int256, int24, int24, CreatedOrder[])
-            );
+            (
+                PoolKey memory poolKey,
+                int24 tickBefore,
+                int24 tickAfter,
+                int128 amount0,
+                int128 amount1,
+                uint160 sqrtPriceX96,
+                CreatedOrder[] memory orders
+            ) = abi.decode(log.data, (PoolKey, int24, int24, int128, int128, uint160, CreatedOrder[]));
 
             swaps[idx] = SwapExecutedLog({
                 sender: address(uint160(uint256(log.topics[1]))),
                 recipient: address(uint160(uint256(log.topics[2]))),
                 poolKey: poolKey,
-                delta: delta,
                 tickBefore: tickBefore,
                 tickAfter: tickAfter,
+                amount0: amount0,
+                amount1: amount1,
+                sqrtPriceX96: sqrtPriceX96,
                 orders: orders
             });
             ++idx;
@@ -782,12 +796,10 @@ contract BaseTest is V4TestSetup, IMsgSender {
 
     function _disableAutoFill() internal returns (uint256 previousMaxFillCount) {
         previousMaxFillCount = limitOrderBook.getMaxFillCount();
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(0);
     }
 
     function _restoreAutoFill(uint256 previousMaxFillCount) internal {
-        vm.prank(users.factoryOwner);
         limitOrderBook.setMaxFillCount(previousMaxFillCount);
     }
 }

package/test/utils/MockWETH.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {IWETH} from "@zoralabs/coins/src/interfaces/IWETH.sol";
+
+contract MockWETH is IWETH, ERC20 {
+    constructor() ERC20("WETH", "WETH") {}
+
+    function approve(address spender, uint256 value) public override(ERC20, IWETH) returns (bool) {
+        return super.approve(spender, value);
+    }
+
+    function transfer(address to, uint256 value) public override(ERC20, IWETH) returns (bool) {
+        return super.transfer(to, value);
+    }
+
+    function transferFrom(address from, address to, uint256 value) public override(ERC20, IWETH) returns (bool) {
+        return super.transferFrom(from, to, value);
+    }
+
+    function balanceOf(address account) public view override(ERC20, IWETH) returns (uint256) {
+        return super.balanceOf(account);
+    }
+
+    function deposit() external payable {
+        _mint(msg.sender, msg.value);
+    }
+
+    function withdraw(uint256 wad) external {
+        _burn(msg.sender, wad);
+        (bool ok, ) = msg.sender.call{value: wad}("");
+        require(ok, "WETH withdraw failed");
+    }
+
+    receive() external payable {
+        _mint(msg.sender, msg.value);
+    }
+}

package/test/utils/TestableZoraLimitOrderBook.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.28;
 import {ZoraLimitOrderBook} from "../../src/ZoraLimitOrderBook.sol";
 import {LimitOrderTypes} from "../../src/libs/LimitOrderTypes.sol";
 import {LimitOrderStorage} from "../../src/libs/LimitOrderStorage.sol";
-import {LimitOrderFill} from "../../src/libs/LimitOrderFill.sol";
+import {LimitOrderViews} from "../../src/libs/LimitOrderViews.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 
 contract TestableZoraLimitOrderBook is ZoraLimitOrderBook {
@@ -12,8 +12,9 @@ contract TestableZoraLimitOrderBook is ZoraLimitOrderBook {
         address poolManager_,
         address zoraCoinVersionLookup_,
         address zoraHookRegistry_,
-        address authority_
-    ) ZoraLimitOrderBook(poolManager_, zoraCoinVersionLookup_, zoraHookRegistry_, authority_) {}
+        address owner_,
+        address weth_
+    ) ZoraLimitOrderBook(poolManager_, zoraCoinVersionLookup_, zoraHookRegistry_, owner_, weth_) {}
 
     function exposedTickQueue(bytes32 poolKeyHash, address coin, int24 tick) external view returns (LimitOrderTypes.Queue memory) {
         return getTickQueue(poolKeyHash, coin, tick);
@@ -38,10 +39,7 @@ contract TestableZoraLimitOrderBook is ZoraLimitOrderBook {
         int24 endTick
     ) external view returns (int24 resolvedStart, int24 resolvedEnd) {
         LimitOrderStorage.Layout storage state = LimitOrderStorage.layout();
-        LimitOrderFill.Context memory ctx;
-        ctx.poolManager = poolManager;
-        ctx.versionLookup = zoraCoinVersionLookup;
-        (, resolvedStart, resolvedEnd) = LimitOrderFill.validateTickRange(state, ctx, key, isCurrency0, startTick, endTick);
+        (, resolvedStart, resolvedEnd) = LimitOrderViews.validateTickRange(state, poolManager, key, isCurrency0, startTick, endTick);
     }
 
     function exposedOrder(bytes32 orderId) external view returns (LimitOrderTypes.LimitOrder memory) {

package/abis/IAuthority.json

@@ -1,31 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "canCall",
-    "inputs": [
-      {
-        "name": "caller",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "target",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "selector",
-        "type": "bytes4",
-        "internalType": "bytes4"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "allowed",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  }
-]