fix: tolerate hook-funded input on exact-output swaps

A v4 hook can pay a swap's input on the caller's behalf. When it covers the
cost in full, PoolManager hands the router the requested positive output
against an input delta of exactly zero. That is solvent -- the hook settles
the debt inside the unlock -- and core permits it explicitly: Hooks.sol:311
notes the caller "has to pay for (or receive) the hook's delta", and IHooks
documents a negative afterSwap return as the hook owing/sending currency.

But it is a shape no ordinary pool produces, where positive output always
implied strictly negative input. Exact output is the only direction that has
to DISCOVER its input by reading a delta, so it is the only one affected:

- The per-hop price guard divides output by input. A zero input panics 0x12,
  even though the realized price is then infinite and clears every finite
  bound it is checked against. Hit _swapExactOutputSingle and, because the
  multihop guard is gated on array presence rather than each bound's value,
  _swapExactOutput whenever minHopPriceX36 was non-empty.
- The multihop loop runs backwards, feeding each hop's input to the previous
  hop as its required output. A funded hop propagated zero, and PoolManager
  rejects amountSpecified == 0 with SwapAmountCannotBeZero.

Skip the division when the input is zero, and stop the backward loop when a
hop consumes nothing -- the upstream hops have nothing left to produce, and
_take/_settle already no-op on zero, so untouched currencies settle cleanly
and an amountIn of 0 trivially clears amountInMaximum.

Over-funding (a hook paying MORE than the cost, leaving a credit whose owner
is undefined in a route) is deliberately left unsupported and still reverts
SafeCastOverflow on the negation, as it does today. Naming that condition
would mean adding an error to IV4Router for no behavior change, so the
interface is untouched; the reasoning is recorded on _swapInput instead.

The fill check runs before the zero-input branch, so all-or-nothing still
holds: a funded hop that underfills reverts V4ExactOutputUnfilled as before.
Exact input is unaffected -- its divisor is the caller's own amountIn, never
a delta, so it can neither divide by zero nor read the sign that overflows.

Also corrects the "output delta will always be positive" comments, which
named a hook case the code does not actually handle: a hook taking more than
the whole output leaves a negative delta and the cast in _swapOutput rejects
it. Documented rather than fixed, since exact input is out of scope here.

Gas +26 single-hop, +54/hop multihop, +96 bytes. Snapshots regenerated
(isolate mode).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dianakocsis

snapshots/V4RouterTest.json

@@ -1,5 +1,5 @@
 {
-  "V4Router_Bytecode": "10415",
+  "V4Router_Bytecode": "10511",
   "V4Router_ExactIn1Hop_nativeIn": "122326",
   "V4Router_ExactIn1Hop_nativeOut": "120793",
   "V4Router_ExactIn1Hop_oneForZero": "129665",
@@ -11,17 +11,17 @@
   "V4Router_ExactInputSingle": "134382",
   "V4Router_ExactInputSingle_nativeIn": "120518",
   "V4Router_ExactInputSingle_nativeOut": "118963",
-  "V4Router_ExactOut1Hop_nativeIn_sweepETH": "128900",
-  "V4Router_ExactOut1Hop_nativeOut": "122321",
-  "V4Router_ExactOut1Hop_oneForZero": "131193",
-  "V4Router_ExactOut1Hop_zeroForOne": "135818",
-  "V4Router_ExactOut2Hops": "192674",
-  "V4Router_ExactOut2Hops_nativeIn": "185756",
-  "V4Router_ExactOut3Hops": "249572",
-  "V4Router_ExactOut3Hops_nativeIn": "242654",
-  "V4Router_ExactOut3Hops_nativeOut": "226823",
-  "V4Router_ExactOutputSingle": "134050",
-  "V4Router_ExactOutputSingle_nativeIn_sweepETH": "127132",
-  "V4Router_ExactOutputSingle_nativeOut": "120566",
-  "router initcode hash (without constructor params, as uint256)": "1906760093307030626709390179699396653508205060645061537790918706363253111413"
+  "V4Router_ExactOut1Hop_nativeIn_sweepETH": "128954",
+  "V4Router_ExactOut1Hop_nativeOut": "122375",
+  "V4Router_ExactOut1Hop_oneForZero": "131247",
+  "V4Router_ExactOut1Hop_zeroForOne": "135872",
+  "V4Router_ExactOut2Hops": "192782",
+  "V4Router_ExactOut2Hops_nativeIn": "185864",
+  "V4Router_ExactOut3Hops": "249734",
+  "V4Router_ExactOut3Hops_nativeIn": "242816",
+  "V4Router_ExactOut3Hops_nativeOut": "226985",
+  "V4Router_ExactOutputSingle": "134076",
+  "V4Router_ExactOutputSingle_nativeIn_sweepETH": "127158",
+  "V4Router_ExactOutputSingle_nativeOut": "120592",
+  "router initcode hash (without constructor params, as uint256)": "42363725424555520568236519911959545672855231110666850371005005945997230752702"
 }

src/V4Router.sol

@@ -115,7 +115,8 @@ abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
             for (uint256 i = 0; i < pathLength; i++) {
                 pathKey = params.path[i];
                 (PoolKey memory poolKey, bool zeroForOne) = pathKey.getPoolAndSwapDirection(currencyIn);
-                // The output delta will always be positive, except for when interacting with certain hook pools
+                // The output delta is positive for ordinary pools. A hook taking more than the whole
+                // output can drive it negative, which is unsupported: _swapOutput reverts on the cast.
                 amountOut =
                     _swapOutput(_swap(poolKey, zeroForOne, -int256(uint256(amountIn)), pathKey.hookData), zeroForOne);
 
@@ -147,7 +148,9 @@ abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
         if (amountOutActual < amountOut) revert V4ExactOutputUnfilled(amountOut, amountOutActual);
         uint128 amountIn = _swapInput(delta, params.zeroForOne);
         if (amountIn > params.amountInMaximum) revert V4TooMuchRequested(params.amountInMaximum, amountIn);
-        if (params.minHopPriceX36 != 0) {
+        // a hook can fund the whole input, leaving a positive output against a zero input. The realized
+        // price is then infinite and clears every finite bound, so skip the division rather than panic.
+        if (params.minHopPriceX36 != 0 && amountIn != 0) {
             uint256 priceX36 = uint256(amountOutActual) * PRECISION / amountIn;
             if (priceX36 < params.minHopPriceX36) {
                 revert V4TooMuchRequestedPerHopSingle(params.minHopPriceX36, priceX36);
@@ -174,7 +177,8 @@ abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
             for (uint256 i = pathLength; i > 0; i--) {
                 pathKey = params.path[i - 1];
                 (PoolKey memory poolKey, bool oneForZero) = pathKey.getPoolAndSwapDirection(currencyOut);
-                // The output delta will always be positive, except for when interacting with certain hook pools
+                // The output delta is positive for ordinary pools. A hook taking more than the whole
+                // output can drive it negative, which is unsupported: _swapOutput reverts on the cast.
                 BalanceDelta delta = _swap(poolKey, !oneForZero, int256(uint256(amountOut)), pathKey.hookData);
                 uint128 amountOutActual = _swapOutput(delta, !oneForZero);
                 // Every hop must fill. PoolManager nets one delta per currency across the whole unlock,
@@ -185,11 +189,19 @@ abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
                 }
                 amountIn = _swapInput(delta, !oneForZero);
 
-                if (perHopPriceLength != 0) {
+                // a hook can fund the whole input, leaving a positive output against a zero input. The
+                // realized price is then infinite and clears every finite bound, so skip the division
+                // rather than panic.
+                if (perHopPriceLength != 0 && amountIn != 0) {
                     uint256 priceX36 = uint256(amountOutActual) * PRECISION / amountIn;
                     uint256 minPrice = params.minHopPriceX36[i - 1];
                     if (priceX36 < minPrice) revert V4TooMuchRequestedPerHop(i - 1, minPrice, priceX36);
                 }
+                // this hop consumed nothing, so the upstream hops have nothing left to produce. Stop
+                // here: propagating the zero would call swap with amountSpecified == 0, which
+                // PoolManager rejects. The untouched currencies carry no delta, so settlement is a
+                // no-op for them and amountIn of 0 trivially clears amountInMaximum below.
+                if (amountIn == 0) break;
                 amountOut = amountIn;
                 currencyOut = pathKey.intermediateCurrency;
             }
@@ -213,13 +225,19 @@ abstract contract V4Router is IV4Router, BaseActionsRouter, DeltaResolver {
 
     /// @notice The positive input amount a swap consumed, derived from its balance delta.
     /// @dev The spent currency's delta is negative (owed to the pool), so negate it to a positive amount.
+    ///      A hook can pay the input on the caller's behalf. Funding it exactly leaves a zero delta,
+    ///      which negates harmlessly to an input of zero and is supported. Paying MORE leaves a positive
+    ///      delta (a credit) whose owner is undefined in a route; that is intentionally unsupported and
+    ///      reverts SafeCastOverflow, since negating it wraps to ~2^256.
     function _swapInput(BalanceDelta delta, bool zeroForOne) private pure returns (uint128) {
         return (uint256(-int256(zeroForOne ? delta.amount0() : delta.amount1()))).toUint128();
     }
 
     /// @notice The positive output amount a swap produced, derived from its balance delta. For an
     ///         exact-output swap this is the REALIZED output, which can be less than the requested
     ///         amount when the pool lacks the liquidity to fill it before the price limit.
+    /// @dev A hook taking more than the whole output leaves a negative delta. That is unsupported: the
+    ///      cast reverts SafeCastOverflow rather than treating the caller as owing the output currency.
     function _swapOutput(BalanceDelta delta, bool zeroForOne) private pure returns (uint128) {
         return (zeroForOne ? delta.amount1() : delta.amount0()).toUint128();
     }

test/mocks/MockFullySubsidizingHook.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {BaseTestHooks} from "@uniswap/v4-core/src/test/BaseTestHooks.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {CurrencySettler} from "@uniswap/v4-core/test/utils/CurrencySettler.sol";
+
+/// @notice A hook that pays some or all of an exact-output swap's input cost out of its own balance.
+///         At the default full subsidy the swapper is left with the requested positive output and a
+///         delta of exactly zero on the input currency.
+/// @dev Unlike `DeltaReturningHook`, which returns a preset amount, this absorbs a share of whatever
+///      the pool actually charged. That is the only way to land the swapper's input delta on exactly
+///      zero, which is the state `V4Router` must tolerate. Requires AFTER_SWAP_FLAG and
+///      AFTER_SWAP_RETURNS_DELTA_FLAG. Fund the hook with the input currency before swapping.
+///
+///      EXACT OUTPUT ONLY. The afterSwap return delta applies to the UNSPECIFIED currency, which is
+///      the input side only for exact output. On an exact-input swap it would land on the output
+///      instead, so this reverts rather than misreporting which side it funded.
+contract MockFullySubsidizingHook is BaseTestHooks {
+    using CurrencySettler for Currency;
+
+    uint256 private constant BPS_DENOMINATOR = 10_000;
+
+    IPoolManager public immutable manager;
+
+    /// @notice Share of the swapper's input this hook pays. 10_000 is the full cost; above that
+    ///         over-funds and leaves the swapper a credit.
+    uint256 public subsidyBps = BPS_DENOMINATOR;
+
+    /// @notice Additional wei paid beyond `subsidyBps`, for exercising the boundary precisely.
+    uint128 public extraWei;
+
+    constructor(IPoolManager _manager) {
+        manager = _manager;
+    }
+
+    modifier onlyPoolManager() {
+        require(msg.sender == address(manager), "not manager");
+        _;
+    }
+
+    function setSubsidyBps(uint256 _subsidyBps) external {
+        subsidyBps = _subsidyBps;
+    }
+
+    function setExtraWei(uint128 _extraWei) external {
+        extraWei = _extraWei;
+    }
+
+    function afterSwap(
+        address, /* sender */
+        PoolKey calldata key,
+        SwapParams calldata params,
+        BalanceDelta delta,
+        bytes calldata /* hookData */
+    ) external override onlyPoolManager returns (bytes4, int128) {
+        require(params.amountSpecified > 0, "exact output only");
+
+        // for exact output the unspecified currency is the input side, which is the side the
+        // afterSwap return delta applies to
+        (Currency inputCurrency, int128 swapperInput) =
+            params.zeroForOne ? (key.currency0, delta.amount0()) : (key.currency1, delta.amount1());
+
+        uint256 fullInput = swapperInput < 0 ? uint256(uint128(-swapperInput)) : 0;
+        uint256 owed = fullInput * subsidyBps / BPS_DENOMINATOR + extraWei;
+        require(owed <= uint256(uint128(type(int128).max)), "subsidy overflows int128");
+
+        // PoolManager applies `swapDelta = swapDelta - hookDelta`, so a negative hook delta moves that
+        // much of the debt off the swapper and onto this hook, which settles it here. Paying the full
+        // input zeroes the swapper's side; paying more leaves them a credit.
+        if (owed != 0) inputCurrency.settle(manager, address(this), owed, false);
+
+        return (IHooks.afterSwap.selector, -int128(int256(owed)));
+    }
+}