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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PanicMonkeys} from "../../src/PanicMonkeys.sol";
import {PanicHook} from "../../src/PanicHook.sol";
import {HookFlags} from "../../src/HookFlags.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Paired", "PAIR") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice A seller recovers the 30% LP share of their own sell tax (and any bot captures every LP bucket)
/// by adding narrow in-range liquidity, calling the permissionless donate(), and removing it in one transaction.
contract JitDonateCaptureTest is Test {
    using StateLibrary for IPoolManager;

    IPoolManager manager;
    PanicMonkeys token;
    PairToken pair;
    PanicHook hook;
    PoolKey key;
    PoolSwapTest router;
    PoolModifyLiquidityTest liquidityRouter;
    address constant BUDGET = address(0xB0D6E7);
    uint160 constant Q96 = 1 << 96;
    int256 constant HONEST_LIQUIDITY = 1_000_000 ether;

    function setUp() public {
        vm.warp(10_000);
        vm.roll(100);
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new PanicMonkeys();
        pair = new PairToken();
        Currency currency = Currency.wrap(address(pair));
        hook = _deployHook(abi.encode(manager, address(token), currency, BUDGET, uint128(1 ether), int24(60)));
        key = PoolKey(
            hook.panicIs0() ? Currency.wrap(address(token)) : currency,
            hook.panicIs0() ? currency : Currency.wrap(address(token)),
            12500,
            60,
            IHooks(address(hook))
        );
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        token.approve(address(router), type(uint256).max);
        token.approve(address(liquidityRouter), type(uint256).max);
        pair.approve(address(router), type(uint256).max);
        pair.approve(address(liquidityRouter), type(uint256).max);
        manager.initialize(key, Q96);
        // Honest LP: wide range.
        _liquidity(-60000, 60000, HONEST_LIQUIDITY);
    }

    function test_sellerRecoversLpShareOfOwnTaxViaJitDonate() public {
        // 1. A sell that moves the price from flat to ~20% down. Pays 20%; 30% of that accrues to lpAccrued.
        _swap(false, 120_000 ether);
        uint256 lpBucket = hook.lpAccrued();
        assertGt(lpBucket, 0);

        // 2. Same transaction: add narrow liquidity around the post-sell tick (100x the honest liquidity,
        //    which in a one-spacing range costs only a fraction of the honest LP's capital).
        (, int24 tick,,) = manager.getSlot0(key.toId());
        int24 lower = (tick / 60) * 60;
        if (lower > tick) lower -= 60;
        int24 upper = lower + 60;
        uint256 pairBefore = pair.balanceOf(address(this));
        _liquidity(lower, upper, HONEST_LIQUIDITY * 100);

        // 3. Permissionless donate() credits whoever is in range right now.
        (bool ok,) = address(hook).call(abi.encodeWithSignature("donate()"));
        ok;

        // 4. Remove the position; principal plus the captured donation comes back.
        _liquidity(lower, upper, -(HONEST_LIQUIDITY * 100));
        int256 gain = int256(pair.balanceOf(address(this))) - int256(pairBefore);

        emit log_named_uint("lp bucket donated", lpBucket);
        emit log_named_int("captured by one-tx JIT position", gain);

        // The in-range LPs who served the sell should receive the LP share; a position that did not exist
        // during the sell must not capture more than a rounding share of it.
        assertLt(gain, int256(lpBucket / 100), "JIT position captured the LP share of the seller's own tax");
    }

    function _deployHook(bytes memory args) internal returns (PanicHook deployed) {
        bytes memory creation = abi.encodePacked(type(PanicHook).creationCode, args);
        bytes32 hash = keccak256(creation);
        for (uint256 i; i < 300_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(predicted, HookFlags.PANIC)) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(at != address(0), "CREATE2 failed");
            return PanicHook(at);
        }
        revert("salt not found");
    }

    function _liquidity(int24 lo, int24 hi, int256 amount) internal returns (BalanceDelta) {
        return liquidityRouter.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, amount, bytes32(0)), "");
    }

    function _swap(bool buy, uint256 amount) internal returns (BalanceDelta) {
        bool zeroForOne = buy != hook.panicIs0();
        return router.swap(
            key,
            SwapParams(
                zeroForOne, -int256(amount), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            ),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }
}

// 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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Paired", "PAIR") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice The 30% LP bucket is paid to whoever is in range when the permissionless donate() runs,
/// so a just-in-time position added and removed around the call, with no trade in between,
/// takes almost all of it from the LPs who actually served the taxed trades.
contract JitDonateProof is Test {
    using StateLibrary for IPoolManager;

    IPoolManager manager;
    PanicMonkeys token;
    PairToken pair;
    PanicHook hook;
    PoolKey key;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    uint160 constant Q96 = 1 << 96;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    address constant ATTACKER = address(0xA77);

    function setUp() public {
        vm.warp(10_000);
        vm.roll(100);
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new PanicMonkeys();
        pair = new PairToken();
        bytes memory creation = abi.encodePacked(
            type(PanicHook).creationCode,
            abi.encode(
                manager, address(token), Currency.wrap(address(pair)), address(0xB0D6E7), uint128(1 ether), int24(60)
            )
        );
        bytes32 h = keccak256(creation);
        for (uint256 i; i < 500_000; ++i) {
            bytes32 salt = bytes32(i);
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, h)))));
            if (uint160(p) & ((1 << 14) - 1) != FLAGS) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(at != address(0), "create2 failed");
            hook = PanicHook(at);
            break;
        }
        require(address(hook) != address(0), "no salt");
        bool p0 = address(token) < address(pair);
        key = PoolKey(
            p0 ? Currency.wrap(address(token)) : Currency.wrap(address(pair)),
            p0 ? Currency.wrap(address(pair)) : Currency.wrap(address(token)),
            12500,
            60,
            IHooks(address(hook))
        );
        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        token.approve(address(router), type(uint256).max);
        token.approve(address(lp), type(uint256).max);
        pair.approve(address(router), type(uint256).max);
        pair.approve(address(lp), type(uint256).max);
        manager.initialize(key, Q96);
        // The honest LP: wide range, serves every trade below.
        lp.modifyLiquidity(key, ModifyLiquidityParams(-60000, 60000, 1_000_000 ether, bytes32(0)), "");
        token.transfer(ATTACKER, 10_000_000 ether);
        pair.transfer(ATTACKER, 10_000_000 ether);
    }

    function test_jitPositionCapturesLpDonation() public {
        // A taxed sell against the honest LP's liquidity accrues the LP bucket.
        bool zfo = hook.panicIs0(); // sell: PANIC in
        router.swap(
            key,
            SwapParams(zfo, -int256(120_000 ether), zfo ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        uint256 bucket = hook.lpAccrued();
        assertGt(bucket, 0, "no LP bucket accrued");

        // Attacker: add a narrow position at the current tick, call donate(), remove. No trade happens.
        (, int24 tick,,) = manager.getSlot0(key.toId());
        int24 lo = (tick / 60) * 60 - 60;
        int24 hi = lo + 120;
        vm.startPrank(ATTACKER);
        token.approve(address(lp), type(uint256).max);
        pair.approve(address(lp), type(uint256).max);
        uint256 pairBefore = pair.balanceOf(ATTACKER);
        uint256 panicBefore = token.balanceOf(ATTACKER);
        lp.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, 10_000_000 ether, bytes32(0)), "");
        hook.donate();
        lp.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, -10_000_000 ether, bytes32(0)), "");
        vm.stopPrank();

        uint256 captured = pair.balanceOf(ATTACKER) - pairBefore;
        emit log_named_uint("LP bucket donated", bucket);
        emit log_named_uint("captured by JIT position", captured);
        emit log_named_uint("captured bps", captured * 10_000 / bucket);
        // The attacker gave up nothing but gas (at most a few wei of rounding).
        assertLe(panicBefore - token.balanceOf(ATTACKER), 10);
        // The bucket exists to pay the LPs that carried the taxed trading; a position that served
        // no trade must not take the majority of it.
        assertLt(captured * 2, bucket, "JIT position captured the majority of the LP donation");
    }
}

// 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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Paired", "PAIR") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice Required test from the brief: splitting one large sell into 10 small sells pays at
/// least as much total hook tax. Same block, same reference, same start and end price.
contract SplitSellProof is Test {
    IPoolManager manager;
    PanicMonkeys token;
    PairToken pair;
    PanicHook hook;
    PoolKey key;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    uint160 constant Q96 = 1 << 96;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);

    function setUp() public {
        vm.warp(10_000);
        vm.roll(100);
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new PanicMonkeys();
        pair = new PairToken();
        bytes memory creation = abi.encodePacked(
            type(PanicHook).creationCode,
            abi.encode(
                manager, address(token), Currency.wrap(address(pair)), address(0xB0D6E7), uint128(1 ether), int24(60)
            )
        );
        bytes32 h = keccak256(creation);
        for (uint256 i; i < 500_000; ++i) {
            bytes32 salt = bytes32(i);
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, h)))));
            if (uint160(p) & ((1 << 14) - 1) != FLAGS) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(at != address(0), "create2 failed");
            hook = PanicHook(at);
            break;
        }
        require(address(hook) != address(0), "no salt");
        bool p0 = address(token) < address(pair);
        key = PoolKey(
            p0 ? Currency.wrap(address(token)) : Currency.wrap(address(pair)),
            p0 ? Currency.wrap(address(pair)) : Currency.wrap(address(token)),
            12500,
            60,
            IHooks(address(hook))
        );
        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        token.approve(address(router), type(uint256).max);
        token.approve(address(lp), type(uint256).max);
        pair.approve(address(router), type(uint256).max);
        pair.approve(address(lp), type(uint256).max);
        manager.initialize(key, Q96);
        lp.modifyLiquidity(key, ModifyLiquidityParams(-60000, 60000, 1_000_000 ether, bytes32(0)), "");
    }

    function _sell(uint256 amount) internal {
        bool zfo = hook.panicIs0();
        router.swap(
            key,
            SwapParams(zfo, -int256(amount), zfo ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function test_tenSmallSellsPayAtLeastAsMuchAsOneLargeSell() public {
        uint256 snap = vm.snapshotState();
        _sell(120_000 ether);
        uint256 oneSellTax = hook.totalFees();
        uint256 endPrice = hook.spotPrice();
        vm.revertToState(snap);
        for (uint256 i; i < 10; ++i) {
            _sell(12_000 ether);
        }
        uint256 splitTax = hook.totalFees();
        emit log_named_uint("one sell hook tax", oneSellTax);
        emit log_named_uint("ten sells hook tax", splitTax);
        // Same reference (same block), same end price, same PANIC sold.
        assertApproxEqAbs(hook.spotPrice(), endPrice, 1e9);
        // Allow one basis point of integer rounding across ten fee computations.
        assertGe(splitTax, oneSellTax - oneSellTax / 10_000, "ten small sells pay less total hook tax than one large sell");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The admission floor (Hook.protected.t.sol) composes the implemented-flag mask from
/// `HookFlags.BEFORE_SWAP_RETURN_DELTA`, `AFTER_SWAP_RETURN_DELTA`, `AFTER_ADD_LIQUIDITY_RETURN_DELTA`
/// and `AFTER_REMOVE_LIQUIDITY_RETURN_DELTA`. On the current tree those members do not exist (the
/// library spells them `*_RETURNS_DELTA`), so this file, like the floor, fails at compile time.
/// Once the four names are exported it compiles and the assertions pass.
contract HookFlagsNamesTest is Test {
    function test_floorSuiteFlagNamesExist() public pure {
        assertEq(HookFlags.BEFORE_SWAP_RETURN_DELTA, uint160(1 << 3));
        assertEq(HookFlags.AFTER_SWAP_RETURN_DELTA, uint160(1 << 2));
        assertEq(HookFlags.AFTER_ADD_LIQUIDITY_RETURN_DELTA, uint160(1 << 1));
        assertEq(HookFlags.AFTER_REMOVE_LIQUIDITY_RETURN_DELTA, uint160(1 << 0));
        uint160 implemented = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
            | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;
        assertEq(implemented, uint160(0x20cc));
    }
}