// 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 {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Work} from "src/Work.sol";
import {WorkLaunchHook} from "src/WorkLaunchHook.sol";

contract ProofPair is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// Exact-output swaps during the 50% launch guard pay only a third of the trader's spend as fee,
/// while exact-input swaps pay half of the output. Same WORK received, 25% less IMD paid.
contract ProofExactOutput is Test {
    address internal constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 internal constant PRICE = 79228162514264337593543950336;
    uint256 internal constant T0 = 1_700_000_000;

    IPoolManager manager;
    Work work;
    ProofPair pair;
    WorkLaunchHook hook;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    PoolKey key;
    bool buyIsZeroForOne;

    function setUp() public {
        vm.warp(T0);
        manager = IPoolManager(address(new PoolManager(address(this))));
        work = new Work();
        vm.etch(IMD, address(new ProofPair()).code);
        pair = ProofPair(IMD);
        pair.mint(address(this), 1e27);
        hook = _deployHook();
        (address c0, address c1) = address(work) < IMD ? (address(work), IMD) : (IMD, address(work));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12500, 60, IHooks(address(hook)));
        buyIsZeroForOne = c0 == IMD;
        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        work.approve(address(router), type(uint256).max);
        pair.approve(address(router), type(uint256).max);
        work.approve(address(lp), type(uint256).max);
        pair.approve(address(lp), type(uint256).max);
        manager.initialize(key, PRICE);
        lp.modifyLiquidity(key, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, bytes32(0)), "");
    }

    function _deployHook() internal returns (WorkLaunchHook) {
        bytes memory initCode = abi.encodePacked(type(WorkLaunchHook).creationCode, abi.encode(manager, address(work)));
        bytes32 h = keccak256(initCode);
        for (uint256 salt; salt < 2_000_000; ++salt) {
            address p =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), h)))));
            if (uint160(p) & 0x3fff == 0x2044 && p.code.length == 0) {
                WorkLaunchHook d = new WorkLaunchHook{salt: bytes32(salt)}(manager, address(work));
                require(address(d) == p);
                return d;
            }
        }
        revert("no salt");
    }

    function _swap(int256 amount) internal returns (BalanceDelta) {
        bool z = buyIsZeroForOne;
        return router.swap(
            key,
            IPoolManager.SwapParams(z, amount, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function _imd(BalanceDelta d) internal view returns (int128) {
        return buyIsZeroForOne ? d.amount0() : d.amount1();
    }

    function _work(BalanceDelta d) internal view returns (int128) {
        return buyIsZeroForOne ? d.amount1() : d.amount0();
    }

    function testExactOutputBuyCostsSameAsExactInputBuyAtLaunch() public {
        assertEq(hook.feeNow(), 5000);
        uint256 snap = vm.snapshotState();

        BalanceDelta dIn = _swap(-100 ether);
        uint256 workOutExactIn = uint256(int256(_work(dIn)));
        uint256 imdPaidExactIn = uint256(-int256(_imd(dIn)));
        assertEq(imdPaidExactIn, 100 ether);
        // ~49.37 WORK: pool gave ~98.74, hook kept 50% of the output.
        assertLt(workOutExactIn, 50 ether);

        vm.revertToState(snap);
        BalanceDelta dOut = _swap(int256(workOutExactIn));
        assertEq(uint256(int256(_work(dOut))), workOutExactIn);
        uint256 imdPaidExactOut = uint256(-int256(_imd(dOut)));

        // Same WORK received from the same pool state under the same 50% guard: the IMD cost must
        // match within price-impact noise. Today exact-output pays ~74.996 IMD against 100 IMD.
        assertApproxEqRel(imdPaidExactOut, imdPaidExactIn, 0.02e18, "exact-output buy is 25% cheaper");
    }
}

// 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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Work} from "src/Work.sol";
import {WorkLaunchHook} from "src/WorkLaunchHook.sol";

contract ProofPair is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// Treasury without a payable receive path (e.g. a contract wallet with no fallback).
contract Rejecter {
    receive() external payable {
        revert("no");
    }
}

/// Anyone can force native value onto the hook with SELFDESTRUCT in a constructor.
contract ForceSend {
    constructor(address payable to) payable {
        selfdestruct(to);
    }
}

/// With a treasury that rejects native value, a 1-wei forced send makes sweep() revert forever,
/// locking every IMD/WORK fee claim in the PoolManager.
contract ProofNativeBrick is Test {
    address internal constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address internal constant B = 0xc9EAFE33A510a3a3d95A94c4f85AdaF6a3EA12a0;
    uint160 internal constant PRICE = 79228162514264337593543950336;
    uint256 internal constant T0 = 1_700_000_000;

    IPoolManager manager;
    Work work;
    ProofPair pair;
    WorkLaunchHook hook;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    PoolKey key;
    bool buyIsZeroForOne;

    function setUp() public {
        vm.warp(T0);
        manager = IPoolManager(address(new PoolManager(address(this))));
        work = new Work();
        vm.etch(IMD, address(new ProofPair()).code);
        pair = ProofPair(IMD);
        pair.mint(address(this), 1e27);
        hook = _deployHook();
        (address c0, address c1) = address(work) < IMD ? (address(work), IMD) : (IMD, address(work));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12500, 60, IHooks(address(hook)));
        buyIsZeroForOne = c0 == IMD;
        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        work.approve(address(router), type(uint256).max);
        pair.approve(address(router), type(uint256).max);
        work.approve(address(lp), type(uint256).max);
        pair.approve(address(lp), type(uint256).max);
        manager.initialize(key, PRICE);
        lp.modifyLiquidity(key, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, bytes32(0)), "");
        vm.etch(B, address(new Rejecter()).code);
    }

    function _deployHook() internal returns (WorkLaunchHook) {
        bytes memory initCode = abi.encodePacked(type(WorkLaunchHook).creationCode, abi.encode(manager, address(work)));
        bytes32 h = keccak256(initCode);
        for (uint256 salt; salt < 2_000_000; ++salt) {
            address p =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), h)))));
            if (uint160(p) & 0x3fff == 0x2044 && p.code.length == 0) {
                WorkLaunchHook d = new WorkLaunchHook{salt: bytes32(salt)}(manager, address(work));
                require(address(d) == p);
                return d;
            }
        }
        revert("no salt");
    }

    function testSweepStillDeliversClaimsAfterForcedWei() public {
        bool z = buyIsZeroForOne;
        router.swap(
            key,
            IPoolManager.SwapParams(z, -100 ether, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        uint256 claims = manager.balanceOf(address(hook), key.currency0.toId())
            + manager.balanceOf(address(hook), key.currency1.toId());
        assertGt(claims, 0);

        address griefer = address(0xBEEF);
        vm.deal(griefer, 1);
        vm.prank(griefer);
        new ForceSend{value: 1}(payable(address(hook)));
        assertEq(address(hook).balance, 1);

        // Expected: the IMD/WORK fee claims still reach the treasury. Actual: sweep() reverts in the
        // native branch of the direct-balance loop and the claims are locked permanently.
        hook.sweep();
        assertEq(manager.balanceOf(address(hook), key.currency0.toId()), 0);
        assertEq(manager.balanceOf(address(hook), key.currency1.toId()), 0);
        assertGt(pair.balanceOf(B) + work.balanceOf(B), 0);
    }
}

// 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 {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Work} from "src/Work.sol";
import {WorkLaunchHook} from "src/WorkLaunchHook.sol";

/// @dev Stand-in for the fixed IMD address; etched there in setUp.
contract ProofIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

/// Exact-input and exact-output purchases of the same WORK amount must lose the same
/// fraction to the hook. Today exact-input loses feeNow()/10000 of the output while
/// exact-output loses only feeNow()/(10000+feeNow()) of the input (33.3% vs 50% at launch).
contract ExactOutputFeeProof is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 constant P = 79228162514264337593543950336;

    IPoolManager m;
    Work w;
    ProofIMD imd;
    WorkLaunchHook h;
    PoolSwapTest r;
    PoolModifyLiquidityTest lr;
    PoolKey k; // hooked pool
    PoolKey ck; // identical pool without the hook, gives the pre-fee amounts

    function setUp() public {
        vm.warp(1_700_000_000);
        m = IPoolManager(address(new PoolManager(address(this))));
        w = new Work();
        vm.etch(IMD, address(new ProofIMD()).code);
        imd = ProofIMD(IMD);
        imd.mint(address(this), 1e27);
        bytes32 hash = keccak256(abi.encodePacked(type(WorkLaunchHook).creationCode, abi.encode(m, address(w))));
        bytes32 salt;
        for (uint256 i; i < 2_000_000; ++i) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash)))));
            if (uint160(p) & 0x3fff == 0x2044) {
                salt = bytes32(i);
                break;
            }
        }
        h = new WorkLaunchHook{salt: salt}(m, address(w));
        k = _key(address(h));
        ck = _key(address(0));
        r = new PoolSwapTest(m);
        lr = new PoolModifyLiquidityTest(m);
        w.approve(address(r), type(uint256).max);
        imd.approve(address(r), type(uint256).max);
        w.approve(address(lr), type(uint256).max);
        imd.approve(address(lr), type(uint256).max);
        m.initialize(k, P);
        m.initialize(ck, P);
        lr.modifyLiquidity(k, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, 0), "");
        lr.modifyLiquidity(ck, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, 0), "");
    }

    function _key(address hooks) internal view returns (PoolKey memory) {
        (address c0, address c1) = address(w) < IMD ? (address(w), IMD) : (IMD, address(w));
        return PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12500, 60, IHooks(hooks));
    }

    function _swap(PoolKey memory key, bool z, int256 amt) internal returns (BalanceDelta) {
        return r.swap(
            key,
            IPoolManager.SwapParams(z, amt, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function testExactOutputBuyPaysSameEffectiveFeeAsExactInputBuy() public {
        assertEq(h.feeNow(), 5000); // same block as initialize: launch rate
        bool buyIsZeroForOne = Currency.unwrap(k.currency0) == IMD;

        // Route A: exact input. Pay 100 IMD, receive WORK after the 50% output haircut.
        BalanceDelta c = _swap(ck, buyIsZeroForOne, -100 ether);
        BalanceDelta a = _swap(k, buyIsZeroForOne, -100 ether);
        uint256 outCtl = uint256(int256(buyIsZeroForOne ? c.amount1() : c.amount0()));
        uint256 outHook = uint256(int256(buyIsZeroForOne ? a.amount1() : a.amount0()));
        uint256 effInBps = 1e4 - outHook * 1e4 / outCtl;

        // Route B: exact output. Ask for exactly the WORK route A delivered; pay IMD plus the hook fee on the input.
        BalanceDelta c2 = _swap(ck, buyIsZeroForOne, int256(outHook));
        BalanceDelta b = _swap(k, buyIsZeroForOne, int256(outHook));
        uint256 inCtl = uint256(-int256(buyIsZeroForOne ? c2.amount0() : c2.amount1()));
        uint256 inHook = uint256(-int256(buyIsZeroForOne ? b.amount0() : b.amount1()));
        uint256 effOutBps = 1e4 - inCtl * 1e4 / inHook;

        emit log_named_uint("control pool WORK out for 100 IMD", outCtl);
        emit log_named_uint("control pool IMD in for that WORK", inCtl);
        emit log_named_uint("WORK bought with 100 IMD via exact-input", outHook);
        emit log_named_uint("IMD paid for that same WORK via exact-output", inHook);
        emit log_named_uint("effective fee bps, exact-input", effInBps);
        emit log_named_uint("effective fee bps, exact-output", effOutBps);

        // The launch guard is a 50% tax on a purchase. Both routes must lose the same fraction (1 bps tolerance).
        assertApproxEqAbs(effOutBps, effInBps, 1, "exact-output route pays a lower effective fee than 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 {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Work} from "src/Work.sol";
import {WorkLaunchHook} from "src/WorkLaunchHook.sol";

/// @dev Stand-in for the fixed IMD address; etched there in setUp.
contract ProofIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

/// Exact-input and exact-output purchases of the same WORK amount must lose the same
/// fraction to the hook. Today exact-input loses feeNow()/10000 of the output while
/// exact-output loses only feeNow()/(10000+feeNow()) of the input (33.3% vs 50% at launch).
contract ExactOutputFeeProof is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 constant P = 79228162514264337593543950336;

    IPoolManager m;
    Work w;
    ProofIMD imd;
    WorkLaunchHook h;
    PoolSwapTest r;
    PoolModifyLiquidityTest lr;
    PoolKey k; // hooked pool
    PoolKey ck; // identical pool without the hook, gives the pre-fee amounts

    function setUp() public {
        vm.warp(1_700_000_000);
        m = IPoolManager(address(new PoolManager(address(this))));
        w = new Work();
        vm.etch(IMD, address(new ProofIMD()).code);
        imd = ProofIMD(IMD);
        imd.mint(address(this), 1e27);
        bytes32 hash = keccak256(abi.encodePacked(type(WorkLaunchHook).creationCode, abi.encode(m, address(w))));
        bytes32 salt;
        for (uint256 i; i < 2_000_000; ++i) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash)))));
            if (uint160(p) & 0x3fff == 0x2044) {
                salt = bytes32(i);
                break;
            }
        }
        h = new WorkLaunchHook{salt: salt}(m, address(w));
        k = _key(address(h));
        ck = _key(address(0));
        r = new PoolSwapTest(m);
        lr = new PoolModifyLiquidityTest(m);
        w.approve(address(r), type(uint256).max);
        imd.approve(address(r), type(uint256).max);
        w.approve(address(lr), type(uint256).max);
        imd.approve(address(lr), type(uint256).max);
        m.initialize(k, P);
        m.initialize(ck, P);
        lr.modifyLiquidity(k, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, 0), "");
        lr.modifyLiquidity(ck, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, 0), "");
    }

    function _key(address hooks) internal view returns (PoolKey memory) {
        (address c0, address c1) = address(w) < IMD ? (address(w), IMD) : (IMD, address(w));
        return PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12500, 60, IHooks(hooks));
    }

    function _swap(PoolKey memory key, bool z, int256 amt) internal returns (BalanceDelta) {
        return r.swap(
            key,
            IPoolManager.SwapParams(z, amt, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function testExactOutputBuyPaysSameEffectiveFeeAsExactInputBuy() public {
        assertEq(h.feeNow(), 5000); // same block as initialize: launch rate
        bool buyIsZeroForOne = Currency.unwrap(k.currency0) == IMD;

        // Route A: exact input. Pay 100 IMD, receive WORK after the 50% output haircut.
        BalanceDelta c = _swap(ck, buyIsZeroForOne, -100 ether);
        BalanceDelta a = _swap(k, buyIsZeroForOne, -100 ether);
        uint256 outCtl = uint256(int256(buyIsZeroForOne ? c.amount1() : c.amount0()));
        uint256 outHook = uint256(int256(buyIsZeroForOne ? a.amount1() : a.amount0()));
        uint256 effInBps = 1e4 - outHook * 1e4 / outCtl;

        // Route B: exact output. Ask for exactly the WORK route A delivered; pay IMD plus the hook fee on the input.
        BalanceDelta c2 = _swap(ck, buyIsZeroForOne, int256(outHook));
        BalanceDelta b = _swap(k, buyIsZeroForOne, int256(outHook));
        uint256 inCtl = uint256(-int256(buyIsZeroForOne ? c2.amount0() : c2.amount1()));
        uint256 inHook = uint256(-int256(buyIsZeroForOne ? b.amount0() : b.amount1()));
        uint256 effOutBps = 1e4 - inCtl * 1e4 / inHook;

        emit log_named_uint("control pool WORK out for 100 IMD", outCtl);
        emit log_named_uint("control pool IMD in for that WORK", inCtl);
        emit log_named_uint("WORK bought with 100 IMD via exact-input", outHook);
        emit log_named_uint("IMD paid for that same WORK via exact-output", inHook);
        emit log_named_uint("effective fee bps, exact-input", effInBps);
        emit log_named_uint("effective fee bps, exact-output", effOutBps);

        // The launch guard is a 50% tax on a purchase. Both routes must lose the same fraction (1 bps tolerance).
        assertApproxEqAbs(effOutBps, effInBps, 1, "exact-output route pays a lower effective fee than 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 {Currency} from "v4-core/src/types/Currency.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Work} from "src/Work.sol";
import {WorkLaunchHook} from "src/WorkLaunchHook.sol";

contract ProofPair is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// Treasury without a payable receive path (e.g. a contract wallet with no fallback).
contract Rejecter {
    receive() external payable {
        revert("no");
    }
}

/// Anyone can force native value onto the hook with SELFDESTRUCT in a constructor.
contract ForceSend {
    constructor(address payable to) payable {
        selfdestruct(to);
    }
}

/// With a treasury that rejects native value, a 1-wei forced send makes sweep() revert forever,
/// locking every IMD/WORK fee claim in the PoolManager.
contract ProofNativeBrick is Test {
    address internal constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address internal constant B = 0xc9EAFE33A510a3a3d95A94c4f85AdaF6a3EA12a0;
    uint160 internal constant PRICE = 79228162514264337593543950336;
    uint256 internal constant T0 = 1_700_000_000;

    IPoolManager manager;
    Work work;
    ProofPair pair;
    WorkLaunchHook hook;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    PoolKey key;
    bool buyIsZeroForOne;

    function setUp() public {
        vm.warp(T0);
        manager = IPoolManager(address(new PoolManager(address(this))));
        work = new Work();
        vm.etch(IMD, address(new ProofPair()).code);
        pair = ProofPair(IMD);
        pair.mint(address(this), 1e27);
        hook = _deployHook();
        (address c0, address c1) = address(work) < IMD ? (address(work), IMD) : (IMD, address(work));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12500, 60, IHooks(address(hook)));
        buyIsZeroForOne = c0 == IMD;
        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        work.approve(address(router), type(uint256).max);
        pair.approve(address(router), type(uint256).max);
        work.approve(address(lp), type(uint256).max);
        pair.approve(address(lp), type(uint256).max);
        manager.initialize(key, PRICE);
        lp.modifyLiquidity(key, IPoolManager.ModifyLiquidityParams(-600, 600, 1_000_000 ether, bytes32(0)), "");
        vm.etch(B, address(new Rejecter()).code);
    }

    function _deployHook() internal returns (WorkLaunchHook) {
        bytes memory initCode = abi.encodePacked(type(WorkLaunchHook).creationCode, abi.encode(manager, address(work)));
        bytes32 h = keccak256(initCode);
        for (uint256 salt; salt < 2_000_000; ++salt) {
            address p =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), h)))));
            if (uint160(p) & 0x3fff == 0x2044 && p.code.length == 0) {
                WorkLaunchHook d = new WorkLaunchHook{salt: bytes32(salt)}(manager, address(work));
                require(address(d) == p);
                return d;
            }
        }
        revert("no salt");
    }

    function testSweepStillDeliversClaimsAfterForcedWei() public {
        bool z = buyIsZeroForOne;
        router.swap(
            key,
            IPoolManager.SwapParams(z, -100 ether, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        uint256 claims = manager.balanceOf(address(hook), key.currency0.toId())
            + manager.balanceOf(address(hook), key.currency1.toId());
        assertGt(claims, 0);

        address griefer = address(0xBEEF);
        vm.deal(griefer, 1);
        vm.prank(griefer);
        new ForceSend{value: 1}(payable(address(hook)));
        assertEq(address(hook).balance, 1);

        // Expected: the IMD/WORK fee claims still reach the treasury. Actual: sweep() reverts in the
        // native branch of the direct-balance loop and the claims are locked permanently.
        hook.sweep();
        assertEq(manager.balanceOf(address(hook), key.currency0.toId()), 0);
        assertEq(manager.balanceOf(address(hook), key.currency1.toId()), 0);
        assertGt(pair.balanceOf(B) + work.balanceOf(B), 0);
    }
}