• mediumA core-valid bounded exact-output swap is rejected by the hook, violating the no-revert requirementsrc/SIMDTESTHook.sol:147

  The hook explicitly rejects a paired-currency exact-output request when the requested amount plus its positive fee exceeds int256.max. Uniswap v4 can execute that nominal request as a small partial fill bounded by sqrtPriceLimitX96. This is an unresolved incompatibility with the task's unconditional requirement that the hook never revert a swap, already acknowledged in the earlier review but not waived by this task.

  No theft or permanent denial of service is demonstrated: ordinary representable swaps continue to work. Removing the check and dropping the fee would restore a fee bypass and would not resolve the requirement. The implementation or the accepted swap-domain specification needs a decision outside this test-only assignment.

  Run the embedded self-contained test as test/scratch/MaximumOutputProof.t.sol with forge test --match-path test/scratch/MaximumOutputProof.t.sol -vv.

  At timestamp 1000000, deploy the real local v4 PoolManager and a CREATE2-mined SIMDTESTHook.

  Initialize hooked and unhooked pools at sqrtPrice 79228162514264337593543950336, fee 12500, tickSpacing 60, and liquidity 1e24 across ticks [-600,600].

  Sell SIMDTEST for exact-output IMD using amountSpecified = type(int256).max and a price limit one tick from the opening price.

  The unhooked control settles a positive IMD output smaller than 100 ether using ordinary funded balances.

  Expected: the hooked pool likewise settles a bounded partial fill and accrues positive fees.

  Actual: the hooked call fails with WrappedError(hook, 0x575e24b4, 0xbc6a922f, 0xa9e35b2f), where 0xbc6a922f is UnrepresentableFee().

  The proof was executed locally and failed at that call after the control assertions passed.

  whole reproduction
  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {SIMDTEST} from "src/SIMDTEST.sol";
  import {SIMDTESTHook} from "src/SIMDTESTHook.sol";
  import {PoolManager} from "v4-core/src/PoolManager.sol";
  import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
  import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
  import {PoolKey} from "v4-core/src/types/PoolKey.sol";
  import {Currency} from "v4-core/src/types/Currency.sol";
  import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
  import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
  import {TickMath} from "v4-core/src/libraries/TickMath.sol";
  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  
  // Entirely local; the production v4 PoolManager handles both pools and settlement.
  contract MaximumOutputProof is Test {
      address constant PAIR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
      uint160 constant PRICE = 79228162514264337593543950336;
      IPoolManager manager;
      SIMDTEST token;
      SIMDTESTHook hook;
      PoolKey hooked;
      PoolKey control;
  
      function setUp() public {
          vm.warp(1_000_000);
          manager = IPoolManager(address(new PoolManager(address(this))));
          token = new SIMDTEST();
          // Use an ordinary 18-decimal ERC20 as offline IMD, at the specified paired address.
          vm.etch(PAIR, address(token).code);
          deal(PAIR, address(this), 1e27, true);
          bytes32 initHash = keccak256(abi.encodePacked(
              type(SIMDTESTHook).creationCode, abi.encode(manager, address(token), address(this))
          ));
          bytes32 salt;
          bool found;
          for (uint256 i; i < 1_000_000; ++i) {
              address predicted = address(uint160(uint256(keccak256(
                  abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)
              ))));
              if (uint160(predicted) & 0x3fff == 0x20cc) {
                  salt = bytes32(i);
                  found = true;
                  break;
              }
          }
          require(found, "salt search failed");
          hook = new SIMDTESTHook{salt: salt}(manager, address(token), address(this));
          hooked = PoolKey({
              currency0: Currency.wrap(address(token) < PAIR ? address(token) : PAIR),
              currency1: Currency.wrap(address(token) < PAIR ? PAIR : address(token)),
              fee: 12500,
              tickSpacing: 60,
              hooks: IHooks(address(hook))
          });
          control = hooked;
          control.hooks = IHooks(address(0));
          manager.initialize(control, PRICE);
          manager.initialize(hooked, PRICE);
          manager.unlock(abi.encode(false, control));
          manager.unlock(abi.encode(false, hooked));
      }
  
      function test_MaximumOutputPartialFillMustNotBeRejectedByHook() public {
          BalanceDelta core = abi.decode(manager.unlock(abi.encode(true, control)), (BalanceDelta));
          int128 filled = Currency.unwrap(control.currency0) == PAIR ? core.amount0() : core.amount1();
          // Core accepts the huge request: the nearby price limit bounds the actual fill.
          assertGt(filled, 0);
          assertLt(uint128(filled), 100 ether);
          assertEq(hook.feeNow(), 4000);
  
          // Expected by the task: another bounded partial fill with positive paired fees.
          // Actual: WrappedError(..., beforeSwap, UnrepresentableFee(), HookCallFailed()).
          BalanceDelta result = abi.decode(manager.unlock(abi.encode(true, hooked)), (BalanceDelta));
          int128 received = Currency.unwrap(hooked.currency0) == PAIR ? result.amount0() : result.amount1();
          assertGt(received, 0);
          assertGt(hook.pending(), 0);
      }
  
      function unlockCallback(bytes calldata data) external returns (bytes memory) {
          require(msg.sender == address(manager), "manager only");
          (bool swap, PoolKey memory key) = abi.decode(data, (bool, PoolKey));
          BalanceDelta delta;
          if (swap) {
              bool zeroForOne = Currency.unwrap(key.currency0) != PAIR;
              delta = manager.swap(key, SwapParams({
                  zeroForOne: zeroForOne,
                  amountSpecified: type(int256).max,
                  sqrtPriceLimitX96: TickMath.getSqrtPriceAtTick(zeroForOne ? int24(-1) : int24(1))
              }), "");
          } else {
              (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-600, 600, 1e24, bytes32(0)), "");
          }
          _settle(key.currency0, delta.amount0());
          _settle(key.currency1, delta.amount1());
          return abi.encode(delta);
      }
  
      function _settle(Currency currency, int128 amount) private {
          if (amount < 0) {
              manager.sync(currency);
              require(IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(amount))));
              manager.settle();
          } else if (amount > 0) {
              manager.take(currency, address(this), uint128(amount));
          }
      }
  }

  whole proof

Failed in the task.