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

import {Test} from "forge-std/Test.sol";
import {RoutrHook} from "src/RoutrHook.sol";
import {RoutrToken} from "src/RoutrToken.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";

/// @dev Launch-factory stand-in: seeds the position, trades, and collects LP fees with a zero liquidity change.
contract FactoryLike is IUnlockCallback {
    using TransientStateLibrary for IPoolManager;

    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function modify(PoolKey memory key, ModifyLiquidityParams memory p) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, abi.encode(p))), (BalanceDelta));
    }

    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(0), key, abi.encode(p))), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (uint8 action, PoolKey memory key, bytes memory p) = abi.decode(data, (uint8, PoolKey, bytes));
        BalanceDelta delta;
        if (action == 0) delta = manager.swap(key, abi.decode(p, (SwapParams)), "");
        else (delta,) = manager.modifyLiquidity(key, abi.decode(p, (ModifyLiquidityParams)), "");
        _settle(key.currency0);
        _settle(key.currency1);
        return abi.encode(delta);
    }

    function _settle(Currency currency) private {
        int256 d = manager.currencyDelta(address(this), currency);
        if (d < 0) {
            manager.sync(currency);
            if (currency.isAddressZero()) {
                manager.settle{value: uint256(-d)}();
            } else {
                RoutrToken(Currency.unwrap(currency)).transfer(address(manager), uint256(-d));
                manager.settle();
            }
        } else if (d > 0) {
            manager.take(currency, address(this), uint256(d));
        }
    }

    receive() external payable {}
}

contract Payee {
    receive() external payable {}
}

/// @notice A zero-liquidity modifyLiquidity (how v4 collects LP fees, and how the IMD launch factory
/// collects the 1.25% pool fee) must succeed and pay the accrued fees, while real removals stay locked.
contract CollectFeesProofTest is Test {
    using StateLibrary for IPoolManager;

    function test_lpFeesCanBeCollectedWhileLiquidityStaysLocked() public {
        PoolManager manager = new PoolManager(address(this));
        RoutrToken token = new RoutrToken();
        FactoryLike factory = new FactoryLike(manager);
        address payable vault = payable(address(new Payee()));
        address payable team = payable(address(new Payee()));

        bytes memory code = bytes.concat(type(RoutrHook).creationCode, abi.encode(manager, token, vault, team));
        bytes32 hash = keccak256(code);
        address hookAddr;
        for (uint256 i; i < 200_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash))))
            );
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != 0x12cc) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                hookAddr := create2(0, add(code, 32), mload(code), salt)
            }
            break;
        }
        require(hookAddr != address(0), "hook not deployed");

        PoolKey memory key =
            PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(hookAddr));
        manager.initialize(key, 79228162514264337593543950336);
        token.transfer(address(factory), 900_000_000 ether);
        vm.deal(address(factory), 1_000_000 ether);
        factory.modify(key, ModifyLiquidityParams(-600, 600, 100_000 ether, bytes32(0)));

        // Trades accrue LP fees in both currencies.
        factory.swap(key, SwapParams(true, -10 ether, TickMath.MIN_SQRT_PRICE + 1));
        factory.swap(key, SwapParams(false, -10 ether, TickMath.MAX_SQRT_PRICE - 1));

        uint128 liquidityBefore = IPoolManager(manager).getLiquidity(key.toId());
        uint256 ethBefore = address(factory).balance;

        // Collect: zero liquidity change. Currently reverts with LiquidityLocked inside beforeRemoveLiquidity.
        BalanceDelta collected = factory.modify(key, ModifyLiquidityParams(-600, 600, 0, bytes32(0)));

        assertGt(collected.amount0(), 0, "accrued ETH LP fees paid out");
        assertGt(collected.amount1(), 0, "accrued ROUTR LP fees paid out");
        assertEq(address(factory).balance - ethBefore, uint256(uint128(collected.amount0())));
        assertEq(IPoolManager(manager).getLiquidity(key.toId()), liquidityBefore, "no liquidity left the pool");

        // Real removal stays locked.
        vm.expectRevert();
        factory.modify(key, ModifyLiquidityParams(-600, 600, -1, bytes32(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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {RoutrHook} from "src/RoutrHook.sol";
import {RoutrToken} from "src/RoutrToken.sol";

/// @dev Minimal launch-factory stand-in: holds the seeded position, collects its LP fees with a
///      zero liquidity change exactly as the launch system's fee collector does, and settles.
contract FactoryProbe is IUnlockCallback {
    IPoolManager immutable manager;
    RoutrToken immutable token;

    constructor(IPoolManager m, RoutrToken t) {
        manager = m;
        token = t;
    }

    function modify(PoolKey memory key, int24 lo, int24 hi, int256 liq) external returns (int128, int128) {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, lo, hi, liq)), (int128, int128));
    }

    function swap(PoolKey memory key, bool buy, int256 amount) external {
        manager.unlock(abi.encode(uint8(0), key, int24(0), int24(0), amount, buy));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        uint8 action = abi.decode(data[:32], (uint8));
        BalanceDelta d;
        PoolKey memory key;
        if (action == 1) {
            int24 lo;
            int24 hi;
            int256 liq;
            (, key, lo, hi, liq) = abi.decode(data, (uint8, PoolKey, int24, int24, int256));
            (d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, liq, bytes32(0)), "");
        } else {
            int256 amount;
            bool buy;
            (, key,,, amount, buy) = abi.decode(data, (uint8, PoolKey, int24, int24, int256, bool));
            d = manager.swap(
                key, SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), ""
            );
        }
        _settle(Currency.wrap(address(0)), d.amount0());
        _settle(Currency.wrap(address(token)), d.amount1());
        return abi.encode(d.amount0(), d.amount1());
    }

    function _settle(Currency c, int128 amt) private {
        if (amt < 0) {
            uint256 owed = uint256(uint128(-amt));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: owed}();
            else {
                token.transfer(address(manager), owed);
                manager.settle();
            }
        } else if (amt > 0) {
            manager.take(c, address(this), uint256(uint128(amt)));
        }
    }

    receive() external payable {}
}

contract FeeCollectLockedTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    RoutrToken token;
    RoutrHook hook;
    FactoryProbe factory;
    FactoryProbe trader;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RoutrToken();
        bytes memory code = bytes.concat(
            type(RoutrHook).creationCode, abi.encode(manager, token, payable(makeAddr("vault")), payable(makeAddr("team")))
        );
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 300_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != 0x12cc) continue;
            bytes32 salt = bytes32(i);
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            hook = RoutrHook(payable(at));
            break;
        }
        require(address(hook) != address(0), "no salt");
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);

        factory = new FactoryProbe(manager, token);
        trader = new FactoryProbe(manager, token);
        token.transfer(address(factory), 400_000_000 ether);
        token.transfer(address(trader), 400_000_000 ether);
        vm.deal(address(factory), 1_000 ether);
        vm.deal(address(trader), 1_000 ether);
    }

    /// @notice The launch factory collects its position's LP fees with a zero liquidity change
    ///         (what v4 routes through beforeRemoveLiquidity). The hook must let that through while
    ///         still refusing every negative liquidity delta.
    function test_factoryCanCollectLPFeesWithZeroDeltaWhileRemovalStaysLocked() public {
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        factory.modify(key, lo, hi, 1e18);

        // Trades accrue the 1.25% LP fee to the factory's position.
        trader.swap(key, true, -1 ether);
        trader.swap(key, false, -1 ether);

        // Principal removal must stay locked for good.
        vm.expectRevert();
        factory.modify(key, lo, hi, -1);

        // Fee collection (zero liquidity change) must succeed and pay the factory, never charge it.
        (int128 a0, int128 a1) = factory.modify(key, lo, hi, 0);
        assertGe(a0, 0, "collect charged the factory ETH");
        assertGe(a1, 0, "collect charged the factory tokens");
        assertTrue(a0 > 0 || a1 > 0, "no LP fees were collected");
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {RoutrHook} from "src/RoutrHook.sol";
import {RoutrToken} from "src/RoutrToken.sol";

/// The launch factory's role: it seeds the position and later collects the position's LP fees with a
/// zero liquidity change (what IMD's PoolFees does). v4 routes a zero liquidityDelta through
/// beforeRemoveLiquidity, which RoutrHook reverts unconditionally, so the 1.25% LP fees owed to the
/// launch payer and the network can never be claimed. This test fails on the current code and passes
/// once beforeRemoveLiquidity lets a zero liquidityDelta through while still reverting every negative one.
contract FactoryLp is IUnlockCallback {
    IPoolManager immutable manager;
    RoutrToken immutable token;

    constructor(IPoolManager m, RoutrToken t) {
        manager = m;
        token = t;
    }

    function modify(PoolKey memory key, int24 lo, int24 hi, int256 liq) external returns (BalanceDelta d) {
        return abi.decode(manager.unlock(abi.encode(uint8(0), key, lo, hi, liq)), (BalanceDelta));
    }

    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta d) {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, p)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        uint8 action = abi.decode(data, (uint8));
        BalanceDelta d;
        PoolKey memory key;
        if (action == 0) {
            (, PoolKey memory k, int24 lo, int24 hi, int256 liq) =
                abi.decode(data, (uint8, PoolKey, int24, int24, int256));
            key = k;
            (d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, liq, bytes32(0)), "");
        } else {
            (, PoolKey memory k, SwapParams memory p) = abi.decode(data, (uint8, PoolKey, SwapParams));
            key = k;
            d = manager.swap(key, p, "");
        }
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return abi.encode(d);
    }

    function _settle(Currency c, int128 a) private {
        if (a < 0) {
            uint256 owed = uint256(uint128(-a));
            manager.sync(c);
            if (c.isAddressZero()) {
                manager.settle{value: owed}();
            } else {
                token.transfer(address(manager), owed);
                manager.settle();
            }
        } else if (a > 0) {
            manager.take(c, address(this), uint256(uint128(a)));
        }
    }

    receive() external payable {}
}

contract FactoryFeeCollectProof is Test {
    using StateLibrary for IPoolManager;

    PoolManager manager;
    RoutrToken token;
    RoutrHook hook;
    FactoryLp factory;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RoutrToken();
        hook = _deployHook();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        factory = new FactoryLp(manager, token);
        token.transfer(address(factory), 900_000_000 ether);
        vm.deal(address(factory), 1_000_000 ether);
        manager.initialize(key, 79228162514264337593543950336);
        factory.modify(key, -600, 600, 100_000 ether);
    }

    function test_factoryCanCollectLpFeesWithZeroLiquidityDelta() public {
        // Trades accrue 1.25% LP fees to the factory's position.
        factory.swap(key, SwapParams(true, -10 ether, TickMath.MIN_SQRT_PRICE + 1));
        factory.swap(key, SwapParams(false, -10 ether, TickMath.MAX_SQRT_PRICE - 1));
        (uint128 liquidityBefore,,) =
            IPoolManager(manager).getPositionInfo(key.toId(), address(factory), -600, 600, bytes32(0));
        assertGt(liquidityBefore, 0);

        // Principal removal must stay locked, for any negative delta.
        vm.expectRevert();
        factory.modify(key, -600, 600, -1);

        // A zero liquidity change removes no principal; it is how the factory collects the pool's LP
        // fees. The hook must let it through. On the current code this call reverts with
        // LiquidityLocked wrapped in Hooks.HookCallFailed.
        uint256 ethBefore = address(factory).balance;
        uint256 tokenBefore = token.balanceOf(address(factory));
        BalanceDelta collected = factory.modify(key, -600, 600, 0);

        // Fees were paid out, nothing was taken from the factory, and liquidity is unchanged.
        assertGe(collected.amount0(), 0, "collect must not charge the factory ETH");
        assertGe(collected.amount1(), 0, "collect must not charge the factory tokens");
        assertTrue(collected.amount0() > 0 || collected.amount1() > 0, "no LP fees collected");
        assertEq(address(factory).balance, ethBefore + uint256(uint128(collected.amount0())));
        assertEq(token.balanceOf(address(factory)), tokenBefore + uint256(uint128(collected.amount1())));
        (uint128 liquidityAfter,,) =
            IPoolManager(manager).getPositionInfo(key.toId(), address(factory), -600, 600, bytes32(0));
        assertEq(liquidityAfter, liquidityBefore, "liquidity principal changed");
    }

    function _deployHook() internal returns (RoutrHook deployed) {
        bytes memory code = bytes.concat(
            type(RoutrHook).creationCode,
            abi.encode(manager, token, payable(address(0xA11CE)), payable(address(0xB0B)))
        );
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 200_000; i++) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != 0x12cc || predicted.code.length != 0) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            require(at == predicted, "CREATE2 deployment failed");
            return RoutrHook(payable(at));
        }
        revert("salt not found");
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {RoutrHook} from "src/RoutrHook.sol";
import {RoutrToken} from "src/RoutrToken.sol";

/// @dev Stands in for the launch factory: holds the seeded position and collects its LP fees with a
///      zero liquidity change, exactly as the launch system's PoolFees does. Also acts as a trader.
contract FactoryAndTrader is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function modify(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, abi.encode(lower, upper, liquidity))), (BalanceDelta));
    }

    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(0), key, abi.encode(p))), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (uint8 action, PoolKey memory key, bytes memory params) = abi.decode(data, (uint8, PoolKey, bytes));
        BalanceDelta delta;
        if (action == 0) {
            delta = manager.swap(key, abi.decode(params, (SwapParams)), "");
        } else {
            (int24 lower, int24 upper, int256 liquidity) = abi.decode(params, (int24, int24, int256));
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liquidity, bytes32(0)), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            uint256 owed = uint256(uint128(-amount));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: owed}();
            else {
                RoutrToken(Currency.unwrap(c)).transfer(address(manager), owed);
                manager.settle();
            }
        } else if (amount > 0) {
            manager.take(c, address(this), uint256(uint128(amount)));
        }
    }

    receive() external payable {}
}

contract FeeCollectLockTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = 0x12cc;

    PoolManager manager;
    RoutrToken token;
    RoutrHook hook;
    FactoryAndTrader factory;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RoutrToken();
        hook = _deployHook();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        factory = new FactoryAndTrader(manager);
        token.transfer(address(factory), 900_000_000 ether);
        vm.deal(address(factory), 1_000_000 ether);
        manager.initialize(key, SQRT_PRICE_1_1);
        // The launch seed: tokens only, upper edge at the opening tick.
        factory.modify(key, -600, 0, 100_000 ether);
        assertEq(address(manager).balance, 0);
    }

    /// Fees accrue to the seeded position on every trade, but the only collection path the launch
    /// system uses (a zero liquidity change by the position holder) is refused by the hook.
    function test_factoryZeroDeltaFeeCollectIsRefusedAlthoughFeesAccrued() public {
        // Buys bring ETH in and pay the 1.25% LP fee in ETH to the seeded position.
        factory.swap(key, SwapParams(true, -10 ether, TickMath.MIN_SQRT_PRICE + 1));
        factory.swap(key, SwapParams(false, -1_000 ether, TickMath.MAX_SQRT_PRICE - 1));

        // Accrued LP fees are owed to the position: fee growth inside the range is non-zero.
        (uint128 liquidity, uint256 feeGrowth0, uint256 feeGrowth1) =
            IPoolManager(manager).getPositionInfo(key.toId(), address(factory), -600, 0, bytes32(0));
        assertEq(liquidity, 100_000 ether);
        (uint256 inside0, uint256 inside1) = IPoolManager(manager).getFeeGrowthInside(key.toId(), -600, 0);
        assertGt(inside0 - feeGrowth0, 0, "ETH LP fees accrued to the seeded position");
        assertGt(inside1 - feeGrowth1, 0, "ROUTR LP fees accrued to the seeded position");

        // The collect: a zero liquidity change by the holder. v4 routes it through beforeRemoveLiquidity.
        // Expected: succeeds with non-negative deltas (the accrued fees). Actual: LiquidityLocked.
        uint256 ethBefore = address(factory).balance;
        BalanceDelta collected = factory.modify(key, -600, 0, 0);
        assertGe(collected.amount0(), 0);
        assertGe(collected.amount1(), 0);
        assertGt(address(factory).balance, ethBefore, "collect paid out the ETH LP fees");
        // Principal stays locked: the position still has its full liquidity afterwards.
        (liquidity,,) = IPoolManager(manager).getPositionInfo(key.toId(), address(factory), -600, 0, bytes32(0));
        assertEq(liquidity, 100_000 ether, "no principal was removed by the collect");
    }

    function _deployHook() internal returns (RoutrHook deployed) {
        bytes memory code = bytes.concat(
            type(RoutrHook).creationCode,
            abi.encode(manager, token, payable(address(0xA11CE)), payable(address(0xB0B)))
        );
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 300_000; i++) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != FLAGS || predicted.code.length != 0) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            require(at == predicted, "CREATE2 deployment failed");
            return RoutrHook(payable(at));
        }
        revert("salt not found");
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {RoutrHook} from "src/RoutrHook.sol";
import {RoutrToken} from "src/RoutrToken.sol";

/// @dev Minimal launch-factory stand-in: holds the seeded position, collects its LP fees with a
///      zero liquidity change exactly as the launch system's fee collector does, and settles.
contract FactoryProbe is IUnlockCallback {
    IPoolManager immutable manager;
    RoutrToken immutable token;

    constructor(IPoolManager m, RoutrToken t) {
        manager = m;
        token = t;
    }

    function modify(PoolKey memory key, int24 lo, int24 hi, int256 liq) external returns (int128, int128) {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, lo, hi, liq)), (int128, int128));
    }

    function swap(PoolKey memory key, bool buy, int256 amount) external {
        manager.unlock(abi.encode(uint8(0), key, int24(0), int24(0), amount, buy));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        uint8 action = abi.decode(data[:32], (uint8));
        BalanceDelta d;
        PoolKey memory key;
        if (action == 1) {
            int24 lo;
            int24 hi;
            int256 liq;
            (, key, lo, hi, liq) = abi.decode(data, (uint8, PoolKey, int24, int24, int256));
            (d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, liq, bytes32(0)), "");
        } else {
            int256 amount;
            bool buy;
            (, key,,, amount, buy) = abi.decode(data, (uint8, PoolKey, int24, int24, int256, bool));
            d = manager.swap(
                key, SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), ""
            );
        }
        _settle(Currency.wrap(address(0)), d.amount0());
        _settle(Currency.wrap(address(token)), d.amount1());
        return abi.encode(d.amount0(), d.amount1());
    }

    function _settle(Currency c, int128 amt) private {
        if (amt < 0) {
            uint256 owed = uint256(uint128(-amt));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: owed}();
            else {
                token.transfer(address(manager), owed);
                manager.settle();
            }
        } else if (amt > 0) {
            manager.take(c, address(this), uint256(uint128(amt)));
        }
    }

    receive() external payable {}
}

contract FeeCollectLockedTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    RoutrToken token;
    RoutrHook hook;
    FactoryProbe factory;
    FactoryProbe trader;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RoutrToken();
        bytes memory code = bytes.concat(
            type(RoutrHook).creationCode, abi.encode(manager, token, payable(makeAddr("vault")), payable(makeAddr("team")))
        );
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 300_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != 0x12cc) continue;
            bytes32 salt = bytes32(i);
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            hook = RoutrHook(payable(at));
            break;
        }
        require(address(hook) != address(0), "no salt");
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);

        factory = new FactoryProbe(manager, token);
        trader = new FactoryProbe(manager, token);
        token.transfer(address(factory), 400_000_000 ether);
        token.transfer(address(trader), 400_000_000 ether);
        vm.deal(address(factory), 1_000 ether);
        vm.deal(address(trader), 1_000 ether);
    }

    /// @notice The launch factory collects its position's LP fees with a zero liquidity change
    ///         (what v4 routes through beforeRemoveLiquidity). The hook must let that through while
    ///         still refusing every negative liquidity delta.
    function test_factoryCanCollectLPFeesWithZeroDeltaWhileRemovalStaysLocked() public {
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        factory.modify(key, lo, hi, 1e18);

        // Trades accrue the 1.25% LP fee to the factory's position.
        trader.swap(key, true, -1 ether);
        trader.swap(key, false, -1 ether);

        // Principal removal must stay locked for good.
        vm.expectRevert();
        factory.modify(key, lo, hi, -1);

        // Fee collection (zero liquidity change) must succeed and pay the factory, never charge it.
        (int128 a0, int128 a1) = factory.modify(key, lo, hi, 0);
        assertGe(a0, 0, "collect charged the factory ETH");
        assertGe(a1, 0, "collect charged the factory tokens");
        assertTrue(a0 > 0 || a1 > 0, "no LP fees were collected");
    }
}