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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";
import {ISwarmlingsHook, Callbacks} from "src/interfaces/IHive.sol";

/// @dev A quoter that prices 3.75% extra on every swap (a VolatilityFee at its cap).
contract FlatQuoter {
    function quoteFee(address, PoolKey calldata, SwapParams calldata, bytes calldata)
        external
        pure
        returns (uint256)
    {
        return 375;
    }
}

contract QuoterSkipTest is Test, Deployers {
    Swarmlings ling;
    SwarmlingsHook hook;
    PoolKey lkey;
    address launcher = makeAddr("launcher");
    address alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        deployFreshManagerAndRouters();
        vm.prank(launcher);
        ling = new Swarmlings(); // native ETH reward off mainnet
        address hookAddr = address(uint160(Hooks.ALL_HOOK_MASK) | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        hook = SwarmlingsHook(payable(hookAddr));
        lkey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        int24 startTick = 177_180;
        manager.initialize(lkey, TickMath.getSqrtPriceAtTick(startTick));
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        uint128 liq = LiquidityAmounts.getLiquidityForAmounts(
            TickMath.getSqrtPriceAtTick(startTick),
            TickMath.getSqrtPriceAtTick(lo),
            TickMath.getSqrtPriceAtTick(hi),
            10 ether,
            800_000_000e18
        );
        vm.deal(launcher, 20 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            lkey, ModifyLiquidityParams(lo, hi, int256(uint256(liq)), 0), ""
        );
        ling.transfer(alice, 50_000_000e18);
        vm.stopPrank();
        vm.prank(alice);
        ling.approve(address(swapRouter), type(uint256).max);
        skip(61);

        ISwarmlingsHook.Module[] memory m = new ISwarmlingsHook.Module[](1);
        m[0] = ISwarmlingsHook.Module(address(new FlatQuoter()), Callbacks.QUOTE, false);
        vm.prank(hook.COUNCIL());
        hook.setModules(m);
    }

    function _sell(uint256 gasLimit) internal returns (bool ok, uint256 bps) {
        uint256 before = hook.totalFees();
        vm.prank(alice);
        try swapRouter.swap{gas: gasLimit}(
            lkey,
            SwapParams(false, -int256(100_000e18), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        ) returns (BalanceDelta d) {
            uint256 fee = hook.totalFees() - before;
            uint256 gross = uint256(uint128(d.amount0())) + fee;
            return (true, fee * 10000 / gross);
        } catch {
            return (false, 0);
        }
    }

    /// Every sell that succeeds must pay the quoted extra: the council's quoter is part of the fee, not an
    /// option the seller can turn off by choosing a tight gas limit.
    function test_sellerCannotSkipQuotedFeeWithTightGas() public {
        (bool ok, uint256 bps) = _sell(5_000_000);
        assertTrue(ok);
        assertEq(bps, 499, "with ample gas a sell pays 1.25% + 3.75% (rounded down)");

        for (uint256 g = 150_000; g < 1_500_000; g += 2_000) {
            (ok, bps) = _sell(g);
            if (ok) {
                emit log_named_uint("first successful gas limit", g);
                emit log_named_uint("bps paid", bps);
                assertEq(bps, 499, "a gas-starved sell skipped the quoter and paid only the holder floor");
                return;
            }
        }
        fail();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";

/// The pool launch.json describes: chain id 1, currency0 = native ETH, currency1 = LING, fee 12500, spacing 60.
contract EthPairOnMainnetScratch is Test, Deployers {
    function test_manifestPoolIsNeverTheLaunchPoolOnMainnet() public {
        vm.chainId(1);
        deployFreshManagerAndRouters();
        address launcher = makeAddr("launcher");
        vm.prank(launcher);
        Swarmlings ling = new Swarmlings();
        address hookAddr = address(Hooks.ALL_HOOK_MASK | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        SwarmlingsHook hook = SwarmlingsHook(payable(hookAddr));
        emit log_named_address("reward currency the hook charges in", Currency.unwrap(hook.reward()));

        PoolKey memory key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr)
        );
        manager.initialize(key, TickMath.getSqrtPriceAtTick(177_180));
        // liquidity from the launcher, as the factory would add it
        vm.deal(launcher, 100 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            key,
            ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(1e21), 0
            ),
            ""
        );
        vm.stopPrank();
        // a buyer in the launch block, inside the 60-second snipe window
        address bob = makeAddr("bob");
        vm.deal(bob, 10 ether);
        vm.prank(bob);
        swapRouter.swap{value: 1 ether}(
            key,
            SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        emit log_named_uint("hook.totalFees after a 1 ETH buy in the snipe window", hook.totalFees());
        emit log_named_uint("snipeBps now", hook.snipeBps());
        vm.expectRevert(SwarmlingsHook.NotLaunched.selector);
        hook.distribute();
        assertTrue(hook.launchPoolSet(), "the manifest's pool is bound as the launch pool");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";

/// @dev launch.json pairs LING with native ETH on chain id 1, where the token fixes its reward currency to IMD.
/// The pool the manifest describes is never charged: no holder fee, no snipe tax, distribute() reverts.
contract EthPairOnMainnet is Test, Deployers {
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    function test_manifestPoolIsNeverCharged() public {
        vm.warp(1_800_000_000);
        vm.chainId(1);
        deployFreshManagerAndRouters();
        deployCodeTo(
            "lib/v4-core/lib/solmate/src/test/utils/mocks/MockERC20.sol:MockERC20",
            abi.encode("Identity.md", "IMD", uint8(18)),
            IMD
        );
        Swarmlings ling = new Swarmlings();
        assertEq(ling.rewardCurrency(), IMD, "on chain id 1 the token rewards in IMD");
        address hookAddr = address(Hooks.ALL_HOOK_MASK | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        SwarmlingsHook hook = SwarmlingsHook(payable(hookAddr));

        // the pool launch.json describes: pairedCurrency 0x0 (native ETH), fee 12500, tick spacing 60
        PoolKey memory key =
            PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        int24 startTick = 177_180;
        manager.initialize(key, TickMath.getSqrtPriceAtTick(startTick));
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        uint128 liq = LiquidityAmounts.getLiquidityForAmounts(
            TickMath.getSqrtPriceAtTick(startTick),
            TickMath.getSqrtPriceAtTick(lo),
            TickMath.getSqrtPriceAtTick(hi),
            10 ether,
            800_000_000e18
        );
        vm.deal(address(this), 100 ether);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            key, ModifyLiquidityParams(lo, hi, int256(uint256(liq)), 0), ""
        );

        // a 1 ETH buy inside the snipe window
        swapRouter.swap{value: 1 ether}(
            key,
            SwapParams(true, -int256(1 ether), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        assertTrue(hook.launchPoolSet(), "the manifest's pool must be the launch pool");
        assertGt(hook.totalFees(), 0, "the holder fee must be taken on the manifest's pool");
    }

}

// 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 {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 {SwapParams, ModifyLiquidityParams} 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 {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";

/// @dev launch.json describes an Ethereum mainnet (chainId 1) pool whose pairedCurrency is native ETH
/// (0x0000000000000000000000000000000000000000), fee 12500, tickSpacing 60, hooked by SwarmlingsHook($poolManager,
/// $token). On chain id 1 the token fixes rewardCurrency to IMD, so the hook never recognises that pool as the
/// launch pool and charges nothing on it. This test sets the manifest's pool up on chain id 1 and expects the
/// launch economics (1.25% holder fee) to apply to it.
contract ManifestPairingTest is Test {
    uint24 constant FEE = 12500;
    int24 constant SPACING = 60;
    address constant PAIRED = address(0); // launch.json pool.pairedCurrency

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    Swarmlings ling;
    SwarmlingsHook hook;
    PoolKey key;
    address launcher = makeAddr("launcher");
    address alice = makeAddr("alice");

    function setUp() public {
        vm.chainId(1); // Ethereum mainnet, as launch.json targets
        vm.warp(1_800_000_000);
        manager = new PoolManager(address(0));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);

        vm.prank(launcher);
        ling = new Swarmlings();

        address hookAddr = address(uint160(Hooks.ALL_HOOK_MASK) | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        hook = SwarmlingsHook(payable(hookAddr));

        // the pool launch.json describes: ETH / LING, fee 12500, spacing 60, this hook
        key = PoolKey(Currency.wrap(PAIRED), Currency.wrap(address(ling)), FEE, SPACING, IHooks(hookAddr));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(177_180));
    }

    function test_manifestPoolIsTheChargedLaunchPool() public {
        assertEq(
            Currency.unwrap(hook.reward()),
            PAIRED,
            "hook fee currency must be the manifest's paired currency, else the manifest pool is never charged"
        );
        assertTrue(hook.launchPoolSet(), "the ETH/LING pool from launch.json must become the launch pool");

        // seed liquidity and buy 1 ETH of LING: holders must receive 1.25%
        int24 lo = TickMath.minUsableTick(SPACING);
        int24 hi = TickMath.maxUsableTick(SPACING);
        vm.deal(launcher, 20 ether);
        vm.startPrank(launcher);
        ling.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 11 ether}(key, ModifyLiquidityParams(lo, hi, 1e20, 0), "");
        vm.stopPrank();

        skip(hook.SNIPE_WINDOW()); // trade after the launch snipe window, so only the 1.25% floor applies
        vm.deal(alice, 2 ether);
        vm.prank(alice);
        swapRouter.swap{value: 1 ether}(
            key,
            SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        assertEq(hook.totalFees(), 1 ether * 125 / 10000, "1.25% of the buy goes to NFT holders");
    }
}

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

import {Test, console} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} 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 {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";
import {SwarmlingsCouncil} from "src/SwarmlingsCouncil.sol";
import {ISwarmlingsHook, Callbacks} from "src/interfaces/IHive.sol";
import {TwapOracle} from "src/modules/TwapOracle.sol";
import {VolatilityFee} from "src/modules/VolatilityFee.sol";

/// @dev A quoter module's extra fee is skipped whenever the swap arrives at `_quote` with less than
/// MODULE_GAS + MODULE_GAS/63 + 30_000 gas left (`_hasGas`), and the swap still completes. A seller who sets a
/// tight gas limit therefore pays only the 1.25% floor while VolatilityFee quotes a live surcharge. The test
/// finds the smallest gas limit at which the sell goes through and expects that sell to have paid the surcharge.
contract QuoterGasBypassTest is Test {
    uint24 constant FEE = 12500;
    int24 constant SPACING = 60;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    Swarmlings ling;
    SwarmlingsHook hook;
    SwarmlingsCouncil council;
    VolatilityFee v;
    TwapOracle o;
    PoolKey key;
    address launcher = makeAddr("launcher");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address carol = makeAddr("carol");

    function setUp() public {
        vm.warp(1_800_000_000); // chain id != 1: the reward currency is native ETH
        manager = new PoolManager(address(0));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        vm.prank(launcher);
        ling = new Swarmlings();
        address hookAddr = address(uint160(Hooks.ALL_HOOK_MASK) | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        hook = SwarmlingsHook(payable(hookAddr));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), FEE, SPACING, IHooks(hookAddr));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(177_180));
        vm.deal(launcher, 20 ether);
        vm.startPrank(launcher);
        ling.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 11 ether}(
            key, ModifyLiquidityParams(TickMath.minUsableTick(SPACING), TickMath.maxUsableTick(SPACING), 2e21, 0), ""
        );
        vm.stopPrank();
        skip(hook.SNIPE_WINDOW());

        address dev = ling.DEV();
        deployCodeTo("SwarmlingsCouncil.sol:SwarmlingsCouncil", abi.encode(dev), hook.COUNCIL());
        council = SwarmlingsCouncil(hook.COUNCIL());
        o = new TwapOracle(hook);
        v = new VolatilityFee(hook, o, 1 hours, 50, 375);
        ISwarmlingsHook.Module[] memory m = new ISwarmlingsHook.Module[](2);
        m[0] = ISwarmlingsHook.Module(address(o), Callbacks.BEFORE_SWAP, false);
        m[1] = ISwarmlingsHook.Module(address(v), Callbacks.QUOTE, false);
        vm.prank(dev);
        council.execute(address(hook), abi.encodeCall(ISwarmlingsHook.setModules, (m)), "attach twap + volatility fee");

        // a quiet hour, then a dump: LING now trades below its 1h average, so sells owe a surcharge
        vm.deal(alice, 10 ether);
        for (uint256 i; i < 6; ++i) {
            _swap(alice, true, -1e9, 1e9, type(uint256).max);
            skip(10 minutes);
        }
        vm.prank(launcher);
        ling.transfer(bob, 150_000_000e18);
        vm.prank(bob);
        ling.approve(address(swapRouter), type(uint256).max);
        _swap(bob, false, -150_000_000e18, 0, type(uint256).max);
        skip(12);
        o.record();
        uint256 unit = ling.UNIT();
        vm.prank(launcher);
        ling.transfer(carol, unit);
        vm.prank(carol);
        ling.approve(address(swapRouter), type(uint256).max);
    }

    function _swap(address who, bool buy, int256 amount, uint256 value, uint256 gas) internal {
        vm.prank(who);
        swapRouter.swap{value: value, gas: gas == type(uint256).max ? gasleft() - 50_000 : gas}(
            key,
            SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function test_gasLimitedSellStillPaysTheQuotedSurcharge() public {
        uint256 extra = v.extraNow();
        assertGt(extra, 0, "the surcharge is live");
        uint256 amount = ling.UNIT() / 2;

        // reference: a sell with plenty of gas pays floor + extra
        uint256 snap = vm.snapshotState();
        uint256 h = hook.totalFees();
        uint256 r = carol.balance;
        _swap(carol, false, -int256(amount), 0, type(uint256).max);
        uint256 fee = hook.totalFees() - h;
        uint256 got = carol.balance - r;
        assertEq(fee, (got + fee) * (125 + extra) / 10000, "a normal sell pays the surcharge");
        vm.revertToState(snap);

        // the smallest gas limit at which the same sell goes through
        uint256 okGas;
        uint256 feeLimited;
        uint256 gotLimited;
        for (uint256 g = 120_000; g <= 800_000; g += 5_000) {
            snap = vm.snapshotState();
            h = hook.totalFees();
            r = carol.balance;
            vm.prank(carol);
            try swapRouter.swap{gas: g}(
                key,
                SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1),
                PoolSwapTest.TestSettings(false, false),
                ""
            ) {
                okGas = g;
                feeLimited = hook.totalFees() - h;
                gotLimited = carol.balance - r;
                break;
            } catch {}
            vm.revertToState(snap);
        }
        console.log("smallest gas limit that completes the sell:", okGas);
        console.log("fee paid at that limit:", feeLimited);
        console.log("fee the quoter asked for:", (gotLimited + feeLimited) * (125 + extra) / 10000);
        assertGt(okGas, 0, "some gas limit completes the sell");
        assertEq(
            feeLimited,
            (gotLimited + feeLimited) * (125 + extra) / 10000,
            "a sell that completes must pay the quoted surcharge, whatever gas it brought"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";
import {ISwarmlingsHook, Callbacks} from "src/interfaces/IHive.sol";

/// @dev A quoter that prices 3.75% extra on every swap (a VolatilityFee at its cap).
contract FlatQuoter {
    function quoteFee(address, PoolKey calldata, SwapParams calldata, bytes calldata)
        external
        pure
        returns (uint256)
    {
        return 375;
    }
}

contract QuoterSkipTest is Test, Deployers {
    Swarmlings ling;
    SwarmlingsHook hook;
    PoolKey lkey;
    address launcher = makeAddr("launcher");
    address alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        deployFreshManagerAndRouters();
        vm.prank(launcher);
        ling = new Swarmlings(); // native ETH reward off mainnet
        address hookAddr = address(uint160(Hooks.ALL_HOOK_MASK) | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        hook = SwarmlingsHook(payable(hookAddr));
        lkey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        int24 startTick = 177_180;
        manager.initialize(lkey, TickMath.getSqrtPriceAtTick(startTick));
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        uint128 liq = LiquidityAmounts.getLiquidityForAmounts(
            TickMath.getSqrtPriceAtTick(startTick),
            TickMath.getSqrtPriceAtTick(lo),
            TickMath.getSqrtPriceAtTick(hi),
            10 ether,
            800_000_000e18
        );
        vm.deal(launcher, 20 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            lkey, ModifyLiquidityParams(lo, hi, int256(uint256(liq)), 0), ""
        );
        ling.transfer(alice, 50_000_000e18);
        vm.stopPrank();
        vm.prank(alice);
        ling.approve(address(swapRouter), type(uint256).max);
        skip(61);

        ISwarmlingsHook.Module[] memory m = new ISwarmlingsHook.Module[](1);
        m[0] = ISwarmlingsHook.Module(address(new FlatQuoter()), Callbacks.QUOTE, false);
        vm.prank(hook.COUNCIL());
        hook.setModules(m);
    }

    function _sell(uint256 gasLimit) internal returns (bool ok, uint256 bps) {
        uint256 before = hook.totalFees();
        vm.prank(alice);
        try swapRouter.swap{gas: gasLimit}(
            lkey,
            SwapParams(false, -int256(100_000e18), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        ) returns (BalanceDelta d) {
            uint256 fee = hook.totalFees() - before;
            uint256 gross = uint256(uint128(d.amount0())) + fee;
            return (true, fee * 10000 / gross);
        } catch {
            return (false, 0);
        }
    }

    /// Every sell that succeeds must pay the quoted extra: the council's quoter is part of the fee, not an
    /// option the seller can turn off by choosing a tight gas limit.
    function test_sellerCannotSkipQuotedFeeWithTightGas() public {
        (bool ok, uint256 bps) = _sell(5_000_000);
        assertTrue(ok);
        assertEq(bps, 499, "with ample gas a sell pays 1.25% + 3.75% (rounded down)");

        for (uint256 g = 150_000; g < 1_500_000; g += 2_000) {
            (ok, bps) = _sell(g);
            if (ok) {
                emit log_named_uint("first successful gas limit", g);
                emit log_named_uint("bps paid", bps);
                assertEq(bps, 499, "a gas-starved sell skipped the quoter and paid only the holder floor");
                return;
            }
        }
        fail();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";

/// The pool launch.json tells the factory to create on chain id 1: currency0 = native ETH (pool.pairedCurrency
/// is the zero address), currency1 = LING, fee 12500, tickSpacing 60, hooks = SwarmlingsHook($poolManager, $token).
/// Expected: the hook binds it as the launch pool and charges the holder fee plus the snipe tax.
/// Actual on this tree: Swarmlings fixes rewardCurrency to IMD on chain id 1, so the hook ignores the pool.
contract ManifestPoolMainnetTest is Test, Deployers {
    function test_manifestPoolIsChargedOnMainnet() public {
        vm.chainId(1);
        deployFreshManagerAndRouters();
        address launcher = makeAddr("launcher");
        vm.prank(launcher);
        Swarmlings ling = new Swarmlings();
        address hookAddr = address(Hooks.ALL_HOOK_MASK | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        SwarmlingsHook hook = SwarmlingsHook(payable(hookAddr));
        emit log_named_address("hook.reward()", Currency.unwrap(hook.reward()));

        PoolKey memory key =
            PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(177_180));

        vm.deal(launcher, 100 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(1e21), 0), ""
        );
        vm.stopPrank();

        // a buyer in the launch block, inside the 60-second snipe window
        address bob = makeAddr("bob");
        vm.deal(bob, 10 ether);
        vm.prank(bob);
        swapRouter.swap{value: 1 ether}(
            key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        emit log_named_uint("hook.totalFees() after a 1 ETH buy", hook.totalFees());
        emit log_named_uint("hook.snipeBps()", hook.snipeBps());

        assertTrue(hook.launchPoolSet(), "the pool launch.json describes must be bound as the launch pool");
        assertEq(Currency.unwrap(hook.reward()), address(0), "the hook must charge in the manifest's paired currency");
        assertGt(hook.totalFees(), 0, "the launch pool must pay the holder fee and the snipe tax");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";
import {ISwarmlingsHook, Callbacks} from "src/interfaces/IHive.sol";

/// @dev A quoter that prices 3.75% extra on every swap (a VolatilityFee at its cap).
contract FlatQuoter {
    function quoteFee(address, PoolKey calldata, SwapParams calldata, bytes calldata)
        external
        pure
        returns (uint256)
    {
        return 375;
    }
}

contract QuoterSkipTest is Test, Deployers {
    Swarmlings ling;
    SwarmlingsHook hook;
    PoolKey lkey;
    address launcher = makeAddr("launcher");
    address alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        deployFreshManagerAndRouters();
        vm.prank(launcher);
        ling = new Swarmlings(); // native ETH reward off mainnet
        address hookAddr = address(uint160(Hooks.ALL_HOOK_MASK) | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        hook = SwarmlingsHook(payable(hookAddr));
        lkey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        int24 startTick = 177_180;
        manager.initialize(lkey, TickMath.getSqrtPriceAtTick(startTick));
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        uint128 liq = LiquidityAmounts.getLiquidityForAmounts(
            TickMath.getSqrtPriceAtTick(startTick),
            TickMath.getSqrtPriceAtTick(lo),
            TickMath.getSqrtPriceAtTick(hi),
            10 ether,
            800_000_000e18
        );
        vm.deal(launcher, 20 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            lkey, ModifyLiquidityParams(lo, hi, int256(uint256(liq)), 0), ""
        );
        ling.transfer(alice, 50_000_000e18);
        vm.stopPrank();
        vm.prank(alice);
        ling.approve(address(swapRouter), type(uint256).max);
        skip(61);

        ISwarmlingsHook.Module[] memory m = new ISwarmlingsHook.Module[](1);
        m[0] = ISwarmlingsHook.Module(address(new FlatQuoter()), Callbacks.QUOTE, false);
        vm.prank(hook.COUNCIL());
        hook.setModules(m);
    }

    function _sell(uint256 gasLimit) internal returns (bool ok, uint256 bps) {
        uint256 before = hook.totalFees();
        vm.prank(alice);
        try swapRouter.swap{gas: gasLimit}(
            lkey,
            SwapParams(false, -int256(100_000e18), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        ) returns (BalanceDelta d) {
            uint256 fee = hook.totalFees() - before;
            uint256 gross = uint256(uint128(d.amount0())) + fee;
            return (true, fee * 10000 / gross);
        } catch {
            return (false, 0);
        }
    }

    /// Every sell that succeeds must pay the quoted extra: the council's quoter is part of the fee, not an
    /// option the seller can turn off by choosing a tight gas limit.
    function test_sellerCannotSkipQuotedFeeWithTightGas() public {
        (bool ok, uint256 bps) = _sell(5_000_000);
        assertTrue(ok);
        assertEq(bps, 499, "with ample gas a sell pays 1.25% + 3.75% (rounded down)");

        for (uint256 g = 150_000; g < 1_500_000; g += 2_000) {
            (ok, bps) = _sell(g);
            if (ok) {
                emit log_named_uint("first successful gas limit", g);
                emit log_named_uint("bps paid", bps);
                assertEq(bps, 499, "a gas-starved sell skipped the quoter and paid only the holder floor");
                return;
            }
        }
        fail();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";

/// The pool launch.json tells the factory to create on chain id 1: currency0 = native ETH (pool.pairedCurrency
/// is the zero address), currency1 = LING, fee 12500, tickSpacing 60, hooks = SwarmlingsHook($poolManager, $token).
/// Expected: the hook binds it as the launch pool and charges the holder fee plus the snipe tax.
/// Actual on this tree: Swarmlings fixes rewardCurrency to IMD on chain id 1, so the hook ignores the pool.
contract ManifestPoolMainnetTest is Test, Deployers {
    function test_manifestPoolIsChargedOnMainnet() public {
        vm.chainId(1);
        deployFreshManagerAndRouters();
        address launcher = makeAddr("launcher");
        vm.prank(launcher);
        Swarmlings ling = new Swarmlings();
        address hookAddr = address(Hooks.ALL_HOOK_MASK | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        SwarmlingsHook hook = SwarmlingsHook(payable(hookAddr));
        emit log_named_address("hook.reward()", Currency.unwrap(hook.reward()));

        PoolKey memory key =
            PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(177_180));

        vm.deal(launcher, 100 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(1e21), 0), ""
        );
        vm.stopPrank();

        // a buyer in the launch block, inside the 60-second snipe window
        address bob = makeAddr("bob");
        vm.deal(bob, 10 ether);
        vm.prank(bob);
        swapRouter.swap{value: 1 ether}(
            key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        emit log_named_uint("hook.totalFees() after a 1 ETH buy", hook.totalFees());
        emit log_named_uint("hook.snipeBps()", hook.snipeBps());

        assertTrue(hook.launchPoolSet(), "the pool launch.json describes must be bound as the launch pool");
        assertEq(Currency.unwrap(hook.reward()), address(0), "the hook must charge in the manifest's paired currency");
        assertGt(hook.totalFees(), 0, "the launch pool must pay the holder fee and the snipe tax");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {Swarmlings} from "src/Swarmlings.sol";
import {SwarmlingsHook} from "src/SwarmlingsHook.sol";
import {ISwarmlingsHook, Callbacks} from "src/interfaces/IHive.sol";

/// @dev A quoter that prices 3.75% extra on every swap (a VolatilityFee at its cap).
contract FlatQuoter {
    function quoteFee(address, PoolKey calldata, SwapParams calldata, bytes calldata)
        external
        pure
        returns (uint256)
    {
        return 375;
    }
}

contract QuoterSkipTest is Test, Deployers {
    Swarmlings ling;
    SwarmlingsHook hook;
    PoolKey lkey;
    address launcher = makeAddr("launcher");
    address alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        deployFreshManagerAndRouters();
        vm.prank(launcher);
        ling = new Swarmlings(); // native ETH reward off mainnet
        address hookAddr = address(uint160(Hooks.ALL_HOOK_MASK) | (uint160(0x4444) << 144));
        deployCodeTo("SwarmlingsHook.sol:SwarmlingsHook", abi.encode(manager, address(ling)), hookAddr);
        hook = SwarmlingsHook(payable(hookAddr));
        lkey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(ling)), 12500, 60, IHooks(hookAddr));
        int24 startTick = 177_180;
        manager.initialize(lkey, TickMath.getSqrtPriceAtTick(startTick));
        int24 lo = TickMath.minUsableTick(60);
        int24 hi = TickMath.maxUsableTick(60);
        uint128 liq = LiquidityAmounts.getLiquidityForAmounts(
            TickMath.getSqrtPriceAtTick(startTick),
            TickMath.getSqrtPriceAtTick(lo),
            TickMath.getSqrtPriceAtTick(hi),
            10 ether,
            800_000_000e18
        );
        vm.deal(launcher, 20 ether);
        vm.startPrank(launcher);
        ling.approve(address(modifyLiquidityRouter), type(uint256).max);
        modifyLiquidityRouter.modifyLiquidity{value: 11 ether}(
            lkey, ModifyLiquidityParams(lo, hi, int256(uint256(liq)), 0), ""
        );
        ling.transfer(alice, 50_000_000e18);
        vm.stopPrank();
        vm.prank(alice);
        ling.approve(address(swapRouter), type(uint256).max);
        skip(61);

        ISwarmlingsHook.Module[] memory m = new ISwarmlingsHook.Module[](1);
        m[0] = ISwarmlingsHook.Module(address(new FlatQuoter()), Callbacks.QUOTE, false);
        vm.prank(hook.COUNCIL());
        hook.setModules(m);
    }

    function _sell(uint256 gasLimit) internal returns (bool ok, uint256 bps) {
        uint256 before = hook.totalFees();
        vm.prank(alice);
        try swapRouter.swap{gas: gasLimit}(
            lkey,
            SwapParams(false, -int256(100_000e18), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        ) returns (BalanceDelta d) {
            uint256 fee = hook.totalFees() - before;
            uint256 gross = uint256(uint128(d.amount0())) + fee;
            return (true, fee * 10000 / gross);
        } catch {
            return (false, 0);
        }
    }

    /// Every sell that succeeds must pay the quoted extra: the council's quoter is part of the fee, not an
    /// option the seller can turn off by choosing a tight gas limit.
    function test_sellerCannotSkipQuotedFeeWithTightGas() public {
        (bool ok, uint256 bps) = _sell(5_000_000);
        assertTrue(ok);
        assertEq(bps, 499, "with ample gas a sell pays 1.25% + 3.75% (rounded down)");

        for (uint256 g = 150_000; g < 1_500_000; g += 2_000) {
            (ok, bps) = _sell(g);
            if (ok) {
                emit log_named_uint("first successful gas limit", g);
                emit log_named_uint("bps paid", bps);
                assertEq(bps, 499, "a gas-starved sell skipped the quoter and paid only the holder floor");
                return;
            }
        }
        fail();
    }
}