@zoralabs/limit-orders 0.2.0 → 0.2.1

package/src/libs/LimitOrderFill.sol

@@ -11,7 +11,6 @@ import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {TickBitmap} from "@uniswap/v4-core/src/libraries/TickBitmap.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
-import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
 import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 
@@ -20,36 +19,17 @@ import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
 import {LimitOrderTypes} from "./LimitOrderTypes.sol";
 import {LimitOrderLiquidity} from "./LimitOrderLiquidity.sol";
 import {LimitOrderCommon} from "./LimitOrderCommon.sol";
+import {LimitOrderViews} from "./LimitOrderViews.sol";
 import {CoinCommon} from "@zoralabs/coins/src/libs/CoinCommon.sol";
 import {IDeployedCoinVersionLookup} from "@zoralabs/coins/src/interfaces/IDeployedCoinVersionLookup.sol";
 
 library LimitOrderFill {
     using PoolIdLibrary for PoolKey;
 
-    int24 internal constant TICK_SENTINEL = type(int24).max;
-
     struct Context {
         IPoolManager poolManager;
         IDeployedCoinVersionLookup versionLookup;
-    }
-
-    function validateTickRange(
-        LimitOrderStorage.Layout storage state,
-        Context memory ctx,
-        PoolKey calldata providedKey,
-        bool isCurrency0,
-        int24 startTick,
-        int24 endTick
-    ) internal view returns (PoolKey memory canonicalKey, int24 resolvedStart, int24 resolvedEnd) {
-        bytes32 poolKeyHash = CoinCommon.hashPoolKey(providedKey);
-        canonicalKey = state.poolKeys[poolKeyHash];
-        if (canonicalKey.tickSpacing == 0) {
-            canonicalKey = providedKey;
-            if (canonicalKey.tickSpacing == 0) revert IZoraLimitOrderBook.InvalidPoolKey();
-        }
-
-        (resolvedStart, resolvedEnd) = _resolveTickRange(ctx.poolManager, canonicalKey, isCurrency0, startTick, endTick);
-        _validateTickRange(isCurrency0, resolvedStart, resolvedEnd);
+        address weth;
     }
 
     function handleFillCallback(LimitOrderStorage.Layout storage state, Context memory ctx, bytes memory callbackData) internal {
@@ -68,10 +48,8 @@ library LimitOrderFill {
             if (key.tickSpacing == 0) revert IZoraLimitOrderBook.InvalidPoolKey();
         }
 
-        int24 currentTick = _currentPoolTick(ctx.poolManager, key);
-
         if (data.orderIds.length == 0) {
-            _fillAcrossRange(state, ctx, data, currentTick);
+            _fillAcrossRange(state, ctx, data);
             return;
         }
 
@@ -89,9 +67,12 @@ library LimitOrderFill {
                 order.status == LimitOrderTypes.OrderStatus.OPEN &&
                 order.poolKeyHash == poolKeyHash &&
                 order.isCurrency0 == isCurrency0 &&
-                order.createdEpoch < currentEpoch &&
-                _hasCrossed(order, currentTick)
+                order.createdEpoch < currentEpoch
             ) {
+                if (!_hasCrossed(order, _currentPoolTick(ctx.poolManager, key))) {
+                    continue;
+                }
+
                 int24 orderTick = LimitOrderCommon.getOrderTick(order);
                 LimitOrderTypes.Queue storage tickQueue = tickQueues[orderTick];
 
@@ -104,12 +85,7 @@ library LimitOrderFill {
         }
     }
 
-    function _fillAcrossRange(
-        LimitOrderStorage.Layout storage state,
-        Context memory ctx,
-        IZoraLimitOrderBook.FillCallbackData memory data,
-        int24 currentTick
-    ) private {
+    function _fillAcrossRange(LimitOrderStorage.Layout storage state, Context memory ctx, IZoraLimitOrderBook.FillCallbackData memory data) private {
         if (data.maxFillCount == 0) {
             return;
         }
@@ -122,6 +98,7 @@ library LimitOrderFill {
         mapping(int24 => LimitOrderTypes.Queue) storage tickQueues = state.tickQueues[poolKeyHash][coin];
         mapping(bytes32 => LimitOrderTypes.LimitOrder) storage orders = state.limitOrders;
         uint256 currentEpoch = state.poolEpochs[poolKeyHash];
+
         bytes32 ordersSlot;
         assembly ("memory-safe") {
             ordersSlot := orders.slot
@@ -133,13 +110,16 @@ library LimitOrderFill {
         int24 cursor = data.startTick;
         int24 target = data.endTick;
         int24 tickSpacing = data.poolKey.tickSpacing;
-
         while (processed < fillCap) {
-            if (zeroDirection ? cursor <= target : cursor >= target) break;
+            if (zeroDirection ? cursor <= target : cursor >= target) {
+                break;
+            }
 
             (int24 nextTick, bool initialized) = TickBitmap.nextInitializedTickWithinOneWord(bitmap, cursor, tickSpacing, zeroDirection);
             bool crossesTarget = zeroDirection ? nextTick <= target : nextTick > target;
-            if (crossesTarget) break;
+            if (crossesTarget) {
+                break;
+            }
 
             if (!initialized) {
                 cursor = zeroDirection ? nextTick - 1 : nextTick;
@@ -177,10 +157,11 @@ library LimitOrderFill {
                     orderId = nextOrderId;
                     continue;
                 }
-                if (order.createdEpoch == currentEpoch) break;
-                if (!_hasCrossed(order, currentTick)) {
-                    orderId = nextOrderId;
-                    continue;
+                if (order.createdEpoch == currentEpoch) {
+                    break;
+                }
+                if (!_hasCrossed(order, _currentPoolTick(ctx.poolManager, data.poolKey))) {
+                    return;
                 }
 
                 _fillOrder(ctx, state, data.poolKey, tickQueue, order, orderId, data.fillReferral);
@@ -207,23 +188,29 @@ library LimitOrderFill {
     ) private {
         order.status = LimitOrderTypes.OrderStatus.FILLED;
 
-        address coin = LimitOrderCommon.getOrderCoin(key, order.isCurrency0);
+        // Get both input and output currencies
+        address coinIn = LimitOrderCommon.getOrderCoin(key, order.isCurrency0);
+        address coinOut = LimitOrderCommon.getOrderCoin(key, !order.isCurrency0);
 
+        // Pass output currency to burnAndPayout (not input currency)
+        // This ensures payout uses the OUTPUT coin's configured payout path
         (Currency coinOutCurrency, uint128 makerAmount, uint128 referralAmount) = LimitOrderLiquidity.burnAndPayout(
             ctx.poolManager,
             key,
             order,
             orderId,
             fillReferral,
-            coin,
-            ctx.versionLookup
+            coinOut,
+            ctx.versionLookup,
+            ctx.weth
         );
 
-        int24 orderTick = LimitOrderCommon.removeOrder(state, key, coin, tickQueue, order);
+        // Use input currency for removing from order book
+        int24 orderTick = LimitOrderCommon.removeOrder(state, key, coinIn, tickQueue, order);
 
         emit IZoraLimitOrderBook.LimitOrderFilled(
             order.maker,
-            coin,
+            coinIn,
             Currency.unwrap(coinOutCurrency),
             order.orderSize,
             makerAmount,
@@ -235,122 +222,6 @@ library LimitOrderFill {
         );
     }
 
-    /**
-     * @notice Derives concrete tick bounds from user input and current pool state.
-     * @dev Callers may pass sentinel values (`-TICK_SENTINEL` / `TICK_SENTINEL`) to mean
-     *      “start at the current tick” or “extend one spacing away”. This helper translates
-     *      those sentinels into real ticks by snapping to the pool’s aligned tick grid and
-     *      offsetting one spacing in the appropriate direction so fills never include
-     *      orders created in the same transaction.
-     *
-     * @param poolManager Pool manager used to read the live tick.
-     * @param key Pool whose tick spacing/current tick drive alignment.
-     * @param isCurrency0 True when targeting currency0 orders (prices above anchor).
-     * @param startTick User-provided start tick or sentinel.
-     * @param endTick User-provided end tick or sentinel.
-     * @return resolvedStart Concrete start tick after resolving sentinels.
-     * @return resolvedEnd Concrete end tick after resolving sentinels.
-     */
-    function _resolveTickRange(
-        IPoolManager poolManager,
-        PoolKey memory key,
-        bool isCurrency0,
-        int24 startTick,
-        int24 endTick
-    ) private view returns (int24 resolvedStart, int24 resolvedEnd) {
-        int24 spacing = key.tickSpacing;
-
-        bool startSentinel = startTick == -TICK_SENTINEL;
-        bool endSentinel = endTick == TICK_SENTINEL;
-
-        (int24 anchorTick, int24 nextAligned, int24 prevAligned) = _alignedTicks(poolManager, key, spacing);
-
-        if (startSentinel) {
-            // Treat sentinel start as anchoring the window at the aligned tick.
-            resolvedStart = anchorTick;
-            resolvedEnd = endSentinel ? (isCurrency0 ? nextAligned : prevAligned) : endTick;
-            return (resolvedStart, resolvedEnd);
-        }
-
-        if (endSentinel) {
-            resolvedStart = startTick;
-            resolvedEnd = isCurrency0 ? nextAligned : anchorTick;
-            return (resolvedStart, resolvedEnd);
-        }
-
-        resolvedStart = startTick;
-        resolvedEnd = endTick;
-        return (resolvedStart, resolvedEnd);
-    }
-
-    /**
-     * @notice Snaps the current pool tick to the nearest aligned tick and returns its neighbors.
-     * @dev Uniswap v4 ticks must lie on multiples of `tickSpacing`. We round the live
-     *      tick down to the nearest aligned value (handling negatives), clamp it inside
-     *      the pool’s usable range, then compute the next/previous aligned ticks for
-     *      callers that need to build deterministic tick windows.
-     *
-     * @param poolManager Pool manager used to read slot0.
-     * @param key Pool key describing the pair and spacing.
-     * @param spacing Tick spacing for this pool.
-     * @return anchorTick Current tick rounded down to the aligned grid.
-     * @return nextAligned Next aligned tick above the anchor (clamped to max usable).
-     * @return prevAligned Previous aligned tick below the anchor (clamped to min usable).
-     */
-    function _alignedTicks(
-        IPoolManager poolManager,
-        PoolKey memory key,
-        int24 spacing
-    ) private view returns (int24 anchorTick, int24 nextAligned, int24 prevAligned) {
-        int24 currentTick = _currentPoolTick(poolManager, key);
-        int256 remainder;
-        assembly ("memory-safe") {
-            remainder := smod(currentTick, spacing)
-        }
-
-        if (remainder == 0) {
-            anchorTick = currentTick;
-        } else if (currentTick >= 0) {
-            anchorTick = int24(int256(currentTick) - remainder);
-        } else {
-            anchorTick = int24(int256(currentTick) - remainder - spacing);
-        }
-
-        int24 minUsable = TickMath.minUsableTick(spacing);
-        int24 maxUsable = TickMath.maxUsableTick(spacing);
-
-        if (anchorTick < minUsable) {
-            anchorTick = minUsable;
-        } else if (anchorTick > maxUsable) {
-            anchorTick = maxUsable;
-        }
-
-        nextAligned = anchorTick + spacing;
-        if (nextAligned > maxUsable) {
-            nextAligned = maxUsable;
-        }
-
-        prevAligned = anchorTick - spacing;
-        if (prevAligned < minUsable) {
-            prevAligned = minUsable;
-        }
-    }
-
-    function _validateTickRange(bool isCurrency0, int24 startTick, int24 endTick) private pure {
-        if (startTick < TickMath.MIN_TICK || startTick > TickMath.MAX_TICK) {
-            revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
-        }
-        if (endTick < TickMath.MIN_TICK || endTick > TickMath.MAX_TICK) {
-            revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
-        }
-
-        if (isCurrency0) {
-            if (startTick > endTick) revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
-        } else {
-            if (startTick < endTick) revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
-        }
-    }
-
     function _currentPoolTick(IPoolManager poolManager, PoolKey memory key) private view returns (int24 tick) {
         (, tick, , ) = StateLibrary.getSlot0(poolManager, key.toId());
     }

package/src/libs/LimitOrderLiquidity.sol

@@ -13,26 +13,19 @@ import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
-import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
 import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
-import {LiquidityAmounts} from "@zoralabs/coins/src/utils/uniswap/LiquidityAmounts.sol";
 
 import {IDeployedCoinVersionLookup} from "@zoralabs/coins/src/interfaces/IDeployedCoinVersionLookup.sol";
 import {LimitOrderTypes} from "./LimitOrderTypes.sol";
 import {IHasSwapPath} from "@zoralabs/coins/src/interfaces/ICoin.sol";
 import {UniV4SwapToCurrency} from "@zoralabs/coins/src/libs/UniV4SwapToCurrency.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {IWETH} from "@zoralabs/coins/src/interfaces/IWETH.sol";
 
 library LimitOrderLiquidity {
     using CurrencyLibrary for Currency;
 
-    function liquidityForOrder(bool isCurrency0, uint256 size, int24 tickLower, int24 tickUpper) internal pure returns (uint128) {
-        uint160 sqrtPriceLower = TickMath.getSqrtPriceAtTick(tickLower);
-        uint160 sqrtPriceUpper = TickMath.getSqrtPriceAtTick(tickUpper);
-        return
-            isCurrency0
-                ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceLower, sqrtPriceUpper, size)
-                : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceLower, sqrtPriceUpper, size);
-    }
+    error WethTransferFailed();
 
     function refundResidual(PoolKey memory key, bool isCurrency0, address maker, uint128 amount) internal {
         if (amount == 0) {
@@ -59,16 +52,18 @@ library LimitOrderLiquidity {
         bytes32 orderId,
         address feeRecipient,
         address coinIn,
-        IDeployedCoinVersionLookup coinLookup
+        IDeployedCoinVersionLookup coinLookup,
+        address weth
     ) internal returns (Currency makerCoinOut, uint128 makerAmountOut, uint128 referralAmountOut) {
-        (BalanceDelta liqDelta, BalanceDelta feesDelta) = poolManager.modifyLiquidity(
+        // Note: callerDelta is a sum of both fee and liquidity deltas
+        (BalanceDelta callerDelta, BalanceDelta feesDelta) = poolManager.modifyLiquidity(
             key,
             ModifyLiquidityParams({tickLower: order.tickLower, tickUpper: order.tickUpper, liquidityDelta: -int256(uint256(order.liquidity)), salt: orderId}),
             ""
         );
 
-        int128 liquidity0 = liqDelta.amount0();
-        int128 liquidity1 = liqDelta.amount1();
+        int128 liquidity0 = callerDelta.amount0();
+        int128 liquidity1 = callerDelta.amount1();
         int128 fee0Initial = feesDelta.amount0();
         int128 fee1Initial = feesDelta.amount1();
 
@@ -77,15 +72,14 @@ library LimitOrderLiquidity {
         int128 referralShareLiquidity0 = feeRecipient == address(0) ? int128(0) : int128(fee0Initial);
         int128 referralShareLiquidity1 = feeRecipient == address(0) ? int128(0) : int128(fee1Initial);
 
-        (bool usePath, IHasSwapPath.PayoutSwapPath memory payoutPath) = _resolvePayoutPath(coinIn, coinLookup);
+        Currency payoutCurrency = order.isCurrency0 ? key.currency1 : key.currency0;
+        IHasSwapPath.PayoutSwapPath memory payoutPath = _resolvePayoutPath(coinIn, coinLookup, key, payoutCurrency);
 
-        (makerCoinOut, makerAmountOut) = _payoutRecipient(poolManager, key, order.maker, makerShareLiquidity0, makerShareLiquidity1, usePath, payoutPath);
+        (makerCoinOut, makerAmountOut) = _payoutRecipient(poolManager, order.maker, makerShareLiquidity0, makerShareLiquidity1, payoutPath, weth);
 
         if (referralShareLiquidity0 > 0 || referralShareLiquidity1 > 0) {
-            (, referralAmountOut) = _payoutRecipient(poolManager, key, feeRecipient, referralShareLiquidity0, referralShareLiquidity1, usePath, payoutPath);
+            (, referralAmountOut) = _payoutRecipient(poolManager, feeRecipient, referralShareLiquidity0, referralShareLiquidity1, payoutPath, weth);
         }
-
-        _settleNegativeDeltas(poolManager, key, liquidity0 + fee0Initial, liquidity1 + fee1Initial);
     }
 
     function burnAndRefund(
@@ -96,19 +90,25 @@ library LimitOrderLiquidity {
         uint128 liquidity,
         bytes32 salt,
         address recipient,
-        bool isCurrency0
+        bool isCurrency0,
+        address weth
     ) internal returns (uint128 amountOut) {
         (int128 amount0, int128 amount1) = _burnLiquidity(poolManager, key, tickLower, tickUpper, liquidity, salt);
 
-        if (isCurrency0 && amount0 > 0) {
-            amountOut = uint128(amount0);
-            poolManager.take(key.currency0, recipient, amountOut);
-        } else if (!isCurrency0 && amount1 > 0) {
-            amountOut = uint128(amount1);
-            poolManager.take(key.currency1, recipient, amountOut);
+        if (amount0 > 0) {
+            uint128 amount0Out = uint128(amount0);
+            _takeCurrency(poolManager, key.currency0, recipient, amount0Out, weth);
+            if (isCurrency0) {
+                amountOut = amount0Out;
+            }
+        }
+        if (amount1 > 0) {
+            uint128 amount1Out = uint128(amount1);
+            _takeCurrency(poolManager, key.currency1, recipient, amount1Out, weth);
+            if (!isCurrency0) {
+                amountOut = amount1Out;
+            }
         }
-
-        _settleNegativeDeltas(poolManager, key, amount0, amount1);
     }
 
     function settleDeltas(IPoolManager poolManager, PoolKey memory key, int256 d0, int256 d1, address payout0, address payout1) internal {
@@ -116,18 +116,28 @@ library LimitOrderLiquidity {
             poolManager.take(key.currency0, payout0, uint256(d0));
         }
         if (d0 < 0) {
+            uint256 amount = uint256(uint256(-d0));
             poolManager.sync(key.currency0);
-            key.currency0.transfer(address(poolManager), uint256(uint256(-d0)));
-            poolManager.settle();
+            if (key.currency0.isAddressZero()) {
+                poolManager.settle{value: amount}();
+            } else {
+                key.currency0.transfer(address(poolManager), amount);
+                poolManager.settle();
+            }
         }
 
         if (d1 > 0 && payout1 != address(0)) {
             poolManager.take(key.currency1, payout1, uint256(d1));
         }
         if (d1 < 0) {
+            uint256 amount = uint256(uint256(-d1));
             poolManager.sync(key.currency1);
-            key.currency1.transfer(address(poolManager), uint256(uint256(-d1)));
-            poolManager.settle();
+            if (key.currency1.isAddressZero()) {
+                poolManager.settle{value: amount}();
+            } else {
+                key.currency1.transfer(address(poolManager), amount);
+                poolManager.settle();
+            }
         }
     }
 
@@ -150,22 +160,28 @@ library LimitOrderLiquidity {
 
     function _resolvePayoutPath(
         address coinIn,
-        IDeployedCoinVersionLookup coinLookup
-    ) private view returns (bool hasPath, IHasSwapPath.PayoutSwapPath memory payoutPath) {
-        if (coinIn == address(0)) {
-            return (false, payoutPath);
-        }
-
-        try coinLookup.getVersionForDeployedCoin(coinIn) returns (uint8 version) {
-            if (version >= 4 && _supportsSwapPath(coinIn)) {
-                payoutPath = IHasSwapPath(coinIn).getPayoutSwapPath(coinLookup);
-                if (payoutPath.path.length > 0) {
-                    return (true, payoutPath);
+        IDeployedCoinVersionLookup coinLookup,
+        PoolKey memory key,
+        Currency payoutCurrency
+    ) private view returns (IHasSwapPath.PayoutSwapPath memory payoutPath) {
+        // Try to get multi-hop path from coin
+        if (coinIn != address(0)) {
+            try coinLookup.getVersionForDeployedCoin(coinIn) returns (uint8 version) {
+                if (version >= 4 && _supportsSwapPath(coinIn)) {
+                    payoutPath = IHasSwapPath(coinIn).getPayoutSwapPath(coinLookup);
+                    // Validate first hop matches expected payout currency
+                    if (payoutPath.path.length > 0 && payoutPath.path[0].intermediateCurrency == payoutCurrency) {
+                        return payoutPath;
+                    }
                 }
-            }
-        } catch {}
+            } catch {}
+        }
 
-        return (false, payoutPath);
+        // Fallback: construct simple single-hop path
+        Currency coinCurrency = payoutCurrency == key.currency0 ? key.currency1 : key.currency0;
+        payoutPath.currencyIn = coinCurrency;
+        payoutPath.path = new PathKey[](1);
+        payoutPath.path[0] = PathKey({intermediateCurrency: payoutCurrency, fee: key.fee, tickSpacing: key.tickSpacing, hooks: key.hooks, hookData: bytes("")});
     }
 
     function _supportsSwapPath(address coin) private view returns (bool) {
@@ -185,38 +201,43 @@ library LimitOrderLiquidity {
         }
     }
 
-    function _payoutRecipient(
-        IPoolManager poolManager,
-        PoolKey memory key,
-        address recipient,
-        int128 amount0,
-        int128 amount1,
-        bool usePath,
-        IHasSwapPath.PayoutSwapPath memory payoutPath
-    ) private returns (Currency coinOut, uint128 amountOut) {
-        if (usePath) {
-            (coinOut, amountOut) = UniV4SwapToCurrency.swapToPath(poolManager, uint128(amount0), uint128(amount1), payoutPath.currencyIn, payoutPath.path);
-            poolManager.take(coinOut, recipient, amountOut);
-        } else {
-            (coinOut, amountOut) = _payCounterAsset(poolManager, key, amount0, amount1, recipient);
+    function _takeCurrency(IPoolManager poolManager, Currency currency, address recipient, uint128 amount, address weth) private {
+        if (!currency.isAddressZero()) {
+            poolManager.take(currency, recipient, amount);
+            return;
+        }
+
+        poolManager.take(currency, address(this), amount);
+        IWETH(weth).deposit{value: amount}();
+        if (!IWETH(weth).transfer(recipient, amount)) {
+            revert WethTransferFailed();
         }
     }
 
-    function _payCounterAsset(
+    function _payoutRecipient(
         IPoolManager poolManager,
-        PoolKey memory key,
+        address recipient,
         int128 amount0,
         int128 amount1,
-        address recipient
+        IHasSwapPath.PayoutSwapPath memory payoutPath,
+        address weth
     ) private returns (Currency coinOut, uint128 amountOut) {
-        if (amount0 > 0) {
-            coinOut = key.currency0;
-            amountOut = uint128(amount0);
-            poolManager.take(coinOut, recipient, amountOut);
-        } else if (amount1 > 0) {
-            coinOut = key.currency1;
-            amountOut = uint128(amount1);
-            poolManager.take(coinOut, recipient, amountOut);
+        // Convert to uint128, treating negative/zero as zero
+        uint128 amt0 = amount0 > 0 ? uint128(amount0) : 0;
+        uint128 amt1 = amount1 > 0 ? uint128(amount1) : 0;
+
+        // Use swapToPath which handles all cases:
+        // - Single positive delta: returns that currency
+        // - Dual positive deltas: swaps one to the other and returns combined amount
+        // - Multi-hop paths: handles coin -> backingCoin -> backingCoin's currency
+        (coinOut, amountOut) = UniV4SwapToCurrency.swapToPath(poolManager, amt0, amt1, payoutPath.currencyIn, payoutPath.path);
+
+        if (amountOut > 0) {
+            Currency payoutCurrency = coinOut;
+            _takeCurrency(poolManager, payoutCurrency, recipient, amountOut, weth);
+            if (payoutCurrency.isAddressZero()) {
+                coinOut = Currency.wrap(weth);
+            }
         }
     }
 }