// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {MeatbagGame, IIntake} from "src/MeatbagGame.sol";
import {MeatbagHerald} from "src/MeatbagHerald.sol";

/// @dev A stand-in for the IMD Intake after IMD retires `oracle-1`, moves the price above 0.5 IMD, or
/// otherwise refuses the request: `request` reverts. Nothing in the game's constants can follow such a
/// change (there is no owner, by design), so this is the state the README says the sunset rule covers.
contract RefusingIntake is IIntake {
    error ActionNotSold();

    function request(bytes32, bytes calldata, Callback calldata, address, uint256)
        external
        payable
        returns (bytes32)
    {
        revert ActionNotSold();
    }
}

contract MintableIMD {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// @title The pot is stranded for good when the Intake refuses `request`
/// @notice `judge()` is the only way a round leaves `Open`; `declareHungJury()` needs `Pending`; the
/// sunset rule needs seven `Hung` rounds. When `Intake.request` reverts, no round can ever become
/// Pending, so no hung jury, no sunset and no claim: the pot (entry fees plus 55% of every trading fee,
/// forever) is locked in the game with no path out. Fails on the current code; passes once a round that
/// cannot be judged has a public, time-gated way to be settled or sunset without the Intake.
contract StrandedPotTest is Test {
    uint256 constant START = 1_800_000_000;

    MeatbagHerald herald;
    MeatbagGame game;
    RefusingIntake intake;
    MintableIMD imd;
    address alice = address(0xA11CE);
    address keeper = address(0xC0FFEE);

    function setUp() public {
        vm.warp(START);
        intake = new RefusingIntake();
        imd = new MintableIMD();
        address predictedGame = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
        herald = new MeatbagHerald(predictedGame);
        game = new MeatbagGame(herald, address(intake), address(imd), address(0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982));
        assertEq(address(game), predictedGame);
        imd.mint(keeper, 100 ether);
        vm.prank(keeper);
        imd.approve(address(game), type(uint256).max);
        vm.deal(alice, 1 ether);
    }

    function test_potCanLeaveTheGameWhenTheIntakeRefusesEveryRequest() public {
        // Trading fees have fed the pot and one human entered today's round.
        (bool ok,) = address(game).call{value: 5 ether}("");
        assertTrue(ok);
        uint256 day = game.today();
        vm.prank(alice);
        game.enter{value: 0.001 ether}("I burnt the toast again and I am not sorry.");
        assertEq(game.pot(), 5.001 ether);

        // The round closes. From here on, every public call that could move the round is tried,
        // once per verdict-timeout, for sixty days: far longer than seven hung juries would take.
        vm.warp((day + 1) * 1 days + 1);
        for (uint256 i = 0; i < 60; i++) {
            vm.prank(keeper);
            try game.judge() {} catch {}
            try game.declareHungJury() {} catch {}
            vm.prank(alice);
            try game.claimSunset(day) {} catch {}
            vm.prank(alice);
            try game.claim() {} catch {}
            vm.warp(block.timestamp + game.VERDICT_TIMEOUT());
        }

        // Expected: the pot is no longer stranded; the entrant (the only one) can get it back by some
        // public path. Actual on the current code: the round is still Open, the pot is still 5.001 ETH,
        // alice has no claim and nothing has left the contract.
        bool recovered = game.pot() < 5.001 ether || game.claimable(alice) > 0 || game.round(day).sunsetShare > 0
            || alice.balance > 1 ether - 0.001 ether;
        assertTrue(recovered, "the pot is stranded: no public path settles, hangs or sunsets an unjudgeable round");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.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 {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {HookFlags} from "src/HookFlags.sol";
import {MeatbagHook} from "src/MeatbagHook.sol";
import {MeatbagToken} from "src/MeatbagToken.sol";
import {MeatbagGame} from "src/MeatbagGame.sol";
import {HeartbeatTreasury} from "src/HeartbeatTreasury.sol";

/// @title A partially filled swap whose ETH side is the specified currency is charged on the whole
/// specified amount, not on the ETH that settled
/// @notice The brief: the hook takes its fee "from the settled ETH delta". The beforeSwap branches
/// (exact-input buy, exact-output sell) fix the fee from `params.amountSpecified` before the pool runs;
/// when `sqrtPriceLimitX96` stops the swap early the pool moves far less ETH, but the fee stays. The
/// afterSwap branches charge on the actual delta, so the two sides of the same fee are asymmetric.
/// Fails on the current code. Passes once the hook either charges 2% of the ETH that actually settled
/// or refuses the partial fill (either keeps the fee at 2% of settled ETH).
contract PartialFillProofTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
        | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;
    address constant SWARM = 0xd01122bBfFd00fc96252c8b29867a5359a3bca13;

    IPoolManager manager;
    MeatbagToken token;
    MeatbagHook hook;
    MeatbagGame game;
    HeartbeatTreasury treasury;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        manager = new PoolManager(address(this));
        token = new MeatbagToken();
        bytes memory creationCode =
            abi.encodePacked(type(MeatbagHook).creationCode, abi.encode(address(manager), address(this)));
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, FLAGS)) continue;
            bytes32 salt = bytes32(i);
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            require(at == predicted, "hook deployment reverted");
            hook = MeatbagHook(payable(at));
            break;
        }
        require(address(hook) != address(0), "no salt");
        game = hook.game();
        treasury = hook.treasury();
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);
        vm.deal(address(this), 1_000_000 ether);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2_000 ether}(
            key, ModifyLiquidityParams(-887220, 887220, 1_000 ether, bytes32(0)), ""
        );
        vm.warp(block.timestamp + 1 hours); // decay over: 2% on buys
    }

    function feeTaken(uint256 potBefore, uint256 swarmBefore, uint256 treasuryBefore) internal view returns (uint256) {
        return (game.pot() - potBefore) + (SWARM.balance - swarmBefore) + (address(treasury).balance - treasuryBefore);
    }

    function test_exactInputBuyStoppedByPriceLimitPaysTwoPercentOfSettledEth() public {
        (uint160 sqrtPrice,,,) = manager.getSlot0(key.toId());
        uint160 limit = uint160(uint256(sqrtPrice) * 999 / 1000);
        uint256 ethBefore = address(this).balance;
        (uint256 p, uint256 s, uint256 t) = (game.pot(), SWARM.balance, address(treasury).balance);

        try swapRouter.swap{value: 10 ether}(
            key, SwapParams(true, -int256(10 ether), limit), PoolSwapTest.TestSettings(false, false), ""
        ) {
            uint256 spent = ethBefore - address(this).balance; // what settled: pool ETH + fee
            uint256 fee = feeTaken(p, s, t);
            // Expected: fee is 2% of the ETH that actually settled (about 0.024 ETH on ~1.2 ETH).
            // Actual: 0.2 ETH, 2% of the 10 ETH that were specified but never swapped.
            assertLe(fee, spent * 200 / 10_000 + 2, "fee charged on the unswapped part of the input");
        } catch {
            // A hook that refuses partial fills on the ETH-specified side also keeps the fee honest.
        }
    }

    function test_exactOutputSellStoppedByPriceLimitPaysTwoPercentOfSettledEth() public {
        (uint160 sqrtPrice,,,) = manager.getSlot0(key.toId());
        uint160 limit = uint160(uint256(sqrtPrice) * 1001 / 1000);
        uint256 ethBefore = address(this).balance;
        (uint256 p, uint256 s, uint256 t) = (game.pot(), SWARM.balance, address(treasury).balance);

        try swapRouter.swap(
            key, SwapParams(false, int256(10 ether), limit), PoolSwapTest.TestSettings(false, false), ""
        ) {
            uint256 received = address(this).balance - ethBefore;
            uint256 fee = feeTaken(p, s, t);
            uint256 gross = received + fee; // the ETH that actually left the pool
            // Expected: 2% of what left the pool (about 0.02 ETH on ~1 ETH). Actual: 0.204 ETH, the
            // gross-up of the 10 ETH that were asked for but never delivered.
            assertLe(fee, gross * 200 / 10_000 + 2, "fee charged on the undelivered part of the ask");
        } catch {}
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {MeatbagGame, IIntake} from "src/MeatbagGame.sol";
import {MeatbagHerald} from "src/MeatbagHerald.sol";

/// @dev The live Intake (0x1397…dea56, Ethereum) reverts `request` when `amount` is below
/// `priceOf(action, asset)` (observed on 2026-10-09 with amount 0.4e18 vs price 0.5e18) and the
/// reference says the price is owner-settable. This mock reproduces exactly that check.
contract PricedIntake is IIntake {
    uint256 public price = 0.5 ether;
    uint256 public count;

    error WrongAmount(uint256 expected, uint256 got);

    function setPrice(uint256 p) external {
        price = p;
    }

    function priceOf(bytes32, address) external view returns (uint256) {
        return price;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 requestId)
    {
        if (amount < price) revert WrongAmount(price, amount);
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        requestId = keccak256(abi.encode("intake", ++count));
    }
}

contract IMDToken is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1_000 ether);
    }
}

contract JudgeBrickTest is Test {
    PricedIntake intake;
    IMDToken imd;
    MeatbagGame game;
    address keeper = address(0xC0FFEE);
    address alice = address(0xA1);

    function setUp() public {
        vm.warp(1_800_000_000);
        intake = new PricedIntake();
        imd = new IMDToken();
        address predictedGame = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
        MeatbagHerald herald = new MeatbagHerald(predictedGame);
        game = new MeatbagGame(herald, address(intake), address(imd), vm.addr(0xA11CE));
        imd.transfer(keeper, 100 ether);
        vm.prank(keeper);
        imd.approve(address(game), type(uint256).max);
        vm.deal(alice, 1 ether);
        vm.deal(address(game), 0);
    }

    /// Fails today: once the Intake's price moves above the hard-coded 0.5 IMD, `judge()` reverts for
    /// every round forever, so no round can ever become Pending, Hung or Settled, the sunset rule can
    /// never fire, and the pot (fed by 55% of every trading fee) is stranded with no owner to fix it.
    /// Passes once `judge()` reads `Intake.priceOf(ACTION, IMD)` and pulls/approves that amount.
    function test_judgeSurvivesAnIntakePriceMove() public {
        vm.prank(alice);
        game.enter{value: 0.001 ether}("I burnt the toast again this morning");
        (bool ok,) = address(game).call{value: 5 ether}(""); // trading fees pushed by the hook
        assertTrue(ok);
        vm.warp((game.today() + 1) * 1 days + 1 hours);

        intake.setPrice(0.6 ether); // IMD moves the price; the keeper holds and approved 100 IMD

        vm.prank(keeper);
        game.judge();

        assertEq(uint8(game.round(game.roundDays(0)).status), uint8(MeatbagGame.Status.Pending));
        assertEq(imd.balanceOf(address(intake)), 0.6 ether, "the keeper paid the live price");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {HookFlags} from "src/HookFlags.sol";
import {MeatbagHook} from "src/MeatbagHook.sol";
import {MeatbagToken} from "src/MeatbagToken.sol";
import {MeatbagGame} from "src/MeatbagGame.sol";
import {HeartbeatTreasury} from "src/HeartbeatTreasury.sol";

/// @notice Finding: an exact-output buy pays the buy fee on the ETH the pool took, not on the ETH the
/// buyer spends, so at launch (25% rate) it pays 20% of its spend while an exact-input buy pays 25%.
/// Fails on the current code; passes once the exact-output buy fee is grossed up
/// (fee = poolEth * rate / (10_000 - rate)) so both buy paths charge `rate` of the buyer's ETH.
contract ProofExactOutBuyBasis is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
        | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;
    address constant SWARM = 0xd01122bBfFd00fc96252c8b29867a5359a3bca13;

    IPoolManager manager;
    MeatbagToken token;
    MeatbagHook hook;
    MeatbagGame game;
    HeartbeatTreasury treasury;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        manager = new PoolManager(address(this));
        token = new MeatbagToken();
        bytes memory creationCode =
            abi.encodePacked(type(MeatbagHook).creationCode, abi.encode(address(manager), address(this)));
        bytes32 initCodeHash = keccak256(creationCode);
        address at;
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            require(at == predicted, "hook deployment reverted");
            break;
        }
        hook = MeatbagHook(payable(at));
        game = hook.game();
        treasury = hook.treasury();
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        key = PoolKey({
            currency0: Currency.wrap(address(0)),
            currency1: Currency.wrap(address(token)),
            fee: 12500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        vm.deal(address(this), 1_000_000 ether);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2_000 ether}(
            key, ModifyLiquidityParams(-887220, 887220, 1_000 ether, bytes32(0)), ""
        );
    }

    function feeTotal() internal view returns (uint256) {
        return game.pot() + SWARM.balance + address(treasury).balance + address(hook).balance;
    }

    function test_exactOutputBuyPaysTheBuyRateOnTheEthSpent() public {
        uint256 rate = hook.buyFeeBps();
        assertEq(rate, 2500, "launch rate");
        uint256 ethBefore = address(this).balance;
        swapRouter.swap{value: 10 ether}(
            key, SwapParams(true, int256(1 ether), TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        uint256 paid = ethBefore - address(this).balance;
        uint256 fee = feeTotal();
        // The brief: 25% at launch on buys. An exact-input buy of `paid` ETH would pay paid * 2500 / 10_000.
        assertApproxEqAbs(fee, paid * rate / 10_000, 2, "exact-output buy must pay the same rate of its ETH as exact-input");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.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 {PoolId} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {HookFlags} from "src/HookFlags.sol";
import {MeatbagHook} from "src/MeatbagHook.sol";
import {MeatbagToken} from "src/MeatbagToken.sol";
import {MeatbagGame} from "src/MeatbagGame.sol";
import {HeartbeatTreasury} from "src/HeartbeatTreasury.sol";

/// @notice Finding: on the two paths where ETH is the specified currency (exact-input buy, exact-output
/// sell) the fee is fixed in beforeSwap from `amountSpecified`, not from the ETH that actually settles.
/// A swap stopped by its price limit moves ~0 ETH yet pays the full fee and is counted as full volume.
/// Fails on the current code; passes once the hook either charges on the settled ETH delta or refuses
/// a swap whose settled ETH is short of the amount the fee was computed on.
contract ProofFeeOnUnfilledAmount is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
        | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;
    address constant SWARM = 0xd01122bBfFd00fc96252c8b29867a5359a3bca13;

    IPoolManager manager;
    MeatbagToken token;
    MeatbagHook hook;
    MeatbagGame game;
    HeartbeatTreasury treasury;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        manager = new PoolManager(address(this));
        token = new MeatbagToken();
        bytes memory creationCode =
            abi.encodePacked(type(MeatbagHook).creationCode, abi.encode(address(manager), address(this)));
        bytes32 initCodeHash = keccak256(creationCode);
        address at;
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            require(at == predicted, "hook deployment reverted");
            break;
        }
        hook = MeatbagHook(payable(at));
        game = hook.game();
        treasury = hook.treasury();
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        key = PoolKey({
            currency0: Currency.wrap(address(0)),
            currency1: Currency.wrap(address(token)),
            fee: 12500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        vm.deal(address(this), 1_000_000 ether);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2_000 ether}(
            key, ModifyLiquidityParams(-887220, 887220, 1_000 ether, bytes32(0)), ""
        );
        vm.warp(hook.launchedAt() + 30 minutes); // 2% flat
    }

    function feeTotal() internal view returns (uint256) {
        return game.pot() + SWARM.balance + address(treasury).balance + address(hook).balance;
    }

    /// An exact-input buy of 100 ETH with the price limit one unit below the current price: the pool
    /// consumes no ETH. The fee must then be nothing (or the swap refused), not 2 ETH.
    function test_unfilledExactInputBuyIsNotChargedTwoEth() public {
        (uint160 price,,,) = manager.getSlot0(key.toId());
        uint256 ethBefore = address(this).balance;
        uint256 tokensBefore = token.balanceOf(address(this));
        try swapRouter.swap{value: 100 ether}(
            key, SwapParams(true, -int256(100 ether), price - 1), PoolSwapTest.TestSettings(false, false), ""
        ) {
            uint256 tokensOut = token.balanceOf(address(this)) - tokensBefore;
            uint256 paid = ethBefore - address(this).balance;
            uint256 fee = feeTotal();
            // 2% of the ETH that actually bought tokens, with 1 wei of rounding room.
            assertLe(fee, (paid - fee) * 200 / 10_000 + 1, "fee charged on 100 ETH that never moved");
            assertLe(hook.volume(), paid, "volume counted ETH that never moved");
            assertTrue(tokensOut > 0 || fee == 0, "paid a fee and received nothing");
        } catch {
            // Refusing the partially-filled swap is also an acceptable fix.
        }
    }

    /// An exact-output sell of 1 ETH with the price limit one unit above the current price: the pool
    /// pays out nothing, yet the seller ends up paying the grossed-up fee of 0.0204 ETH to the hook.
    function test_unfilledExactOutputSellDoesNotMakeTheSellerPayEth() public {
        (uint160 price,,,) = manager.getSlot0(key.toId());
        uint256 ethBefore = address(this).balance;
        try swapRouter.swap{value: 1 ether}(
            key, SwapParams(false, int256(1 ether), price + 1), PoolSwapTest.TestSettings(false, false), ""
        ) {
            assertGe(address(this).balance, ethBefore, "a seller must never pay ETH");
        } catch {
            // Refusing the partially-filled swap is also an acceptable fix.
        }
    }
}