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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice An exact-input buy that only partially fills (price limit or exhausted liquidity) is charged the
/// 1% dip fee on the whole requested input, not on what the pool actually consumed. The effective hook fee
/// on the executed trade then far exceeds the 30% ceiling the brief guarantees.
contract PartialFillBuyFeeTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;
    address oracleFund = makeAddr("oracleFund");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), oracleFund)
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), oracleFund);
        assertEq(address(hook), predicted);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(1e22)),
                salt: 0
            }),
            ""
        );
    }

    function _swap(bool zeroForOne, int256 amountSpecified, uint160 limit, uint256 value)
        internal
        returns (BalanceDelta)
    {
        return swapRouter.swap{value: value}(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function _sqrtPrice() internal view returns (uint160 p) {
        (p,,,) = IPoolManager(address(manager)).getSlot0(poolId);
    }

    function test_partialFillExactInputBuyIsChargedOnTheUnfilledInput() public {
        // Crash the price about 20% below the reference so buys pay the 1% dip fee.
        _swap(false, -int256(1e26), uint160(uint256(SQRT_PRICE_1_1) * 1118 / 1000), 0);
        assertGe(hook.currentDrawdownBps(), 500, "down: buys are fee-bearing");

        // A buyer sends 1000 ETH with a price limit that only lets the pool consume a small part of it.
        uint160 before = _sqrtPrice();
        uint160 limit = uint160(uint256(before) * 999 / 1000); // allow ~0.2% of price movement
        uint256 feesBefore = hook.totalAccruedFees();
        uint256 ethBefore = address(this).balance;
        BalanceDelta d = _swap(true, -1000 ether, limit, 1000 ether);
        uint256 fee = hook.totalAccruedFees() - feesBefore;
        uint256 paidTotal = ethBefore - address(this).balance;
        uint256 poolInput = paidTotal - fee;

        emit log_named_uint("pool consumed (wei of ETH)", poolInput);
        emit log_named_uint("hook fee charged (wei of ETH)", fee);
        emit log_named_uint("fee in bps of the executed input", fee * 10_000 / poolInput);

        assertLt(poolInput, 100 ether, "only a small part of the 1000 ETH order filled");
        assertEq(uint256(-int256(d.amount0())), paidTotal);
        // The brief: buys pay 1% when down and the hook fee never exceeds 30%. On this code the fee is 1% of
        // the whole 1000 ETH request (10 ETH) against a fill of about 9 ETH: more than 100% of the trade.
        assertLe(fee * 10_000, paidTotal * 3000, "hook fee must never exceed 30% of what the swapper paid");
        assertLe(fee * 10_000, (poolInput + fee) * 100 + 10_000, "a down-market buy pays 1% of its input");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The 30% LP share is paid by a permissionless `donateToLiquidityProviders()` to whoever is in
/// range at the moment of the call. Anyone can add a huge single-tick position, call it, and remove the
/// position in one transaction, taking essentially the whole bucket away from the real LPs.
contract JitDonationTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;
    uint128 constant FULL_RANGE_LIQUIDITY = 1e22;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        require(address(hook) == predicted, "hook address mismatch");

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        // The honest LP: full range.
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(FULL_RANGE_LIQUIDITY)),
                salt: 0
            }),
            ""
        );
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    function _sqrtPriceAtDrawdown(uint160 refSqrt, uint256 drawdownBps) internal pure returns (uint160) {
        uint256 ref2 = uint256(refSqrt) * uint256(refSqrt);
        return uint160(_sqrt(ref2 * 10_000 / (10_000 - drawdownBps)) + 1);
    }

    function test_jitLiquidityCapturesTheWholeLpDonation() public {
        // A 20% crash fills the donation bucket.
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);
        swapRouter.swap(
            key,
            SwapParams({
                zeroForOne: false,
                amountSpecified: -int256(1e26),
                sqrtPriceLimitX96: _sqrtPriceAtDrawdown(hook.referenceSqrtPriceX96(), 2000)
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
        uint256 bucket = hook.donationBucket();
        assertGt(bucket, 0);

        // Attacker, in one transaction: add a huge position covering only the current tick spacing,
        // call the permissionless donate, remove the position.
        address attacker = makeAddr("attacker");
        vm.deal(attacker, 1e27);
        panic.transfer(attacker, 1e26);
        vm.startPrank(attacker);
        panic.approve(address(lpRouter), type(uint256).max);

        (, int24 tick,,) = IPoolManager(address(manager)).getSlot0(poolId);
        int24 lower = (tick / TICK_SPACING) * TICK_SPACING;
        if (tick < 0 && tick % TICK_SPACING != 0) lower -= TICK_SPACING;
        int24 upper = lower + TICK_SPACING;
        uint128 jit = FULL_RANGE_LIQUIDITY * 10_000;

        uint256 ethBefore = attacker.balance;
        uint256 panicBefore = panic.balanceOf(attacker);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({tickLower: lower, tickUpper: upper, liquidityDelta: int256(uint256(jit)), salt: 0}),
            ""
        );
        uint256 ethAfterAdd = attacker.balance;
        // The router keeps unspent msg.value; measure what the position actually cost.
        uint256 routerEth = address(lpRouter).balance;

        (bool ok,) = address(hook).call(abi.encodeWithSignature("donateToLiquidityProviders()"));
        ok; // may be a no-op or revert on a fixed contract; what matters is where the money went

        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({tickLower: lower, tickUpper: upper, liquidityDelta: -int256(uint256(jit)), salt: 0}),
            ""
        );
        vm.stopPrank();

        int256 ethGain = int256(attacker.balance + routerEth) - int256(ethBefore);
        int256 panicGain = int256(panic.balanceOf(attacker)) - int256(panicBefore);
        ethAfterAdd;

        emit log_named_uint("donation bucket (ETH wei)", bucket);
        emit log_named_int("attacker ETH gain       ", ethGain);
        emit log_named_int("attacker PANIC change   ", panicGain);
        emit log_named_int("captured bps of bucket  ", ethGain * 10_000 / int256(bucket));

        // The LP share is meant for the pool's liquidity providers. A flash position that exists only
        // for the donate call must not be able to take the bulk of it.
        assertLt(ethGain, int256(bucket / 2), "a JIT position captured most 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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice An exact-input buy while the price is down pays the 1% hook fee on the amount it ASKED to
/// spend, not on the amount the pool actually consumed. With a price limit that fills only a sliver of
/// the order, the swapper is charged a fee many times larger than 1% of what was swapped.
contract PartialFillBuyFeeTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;
    uint128 constant FULL_RANGE_LIQUIDITY = 1e22;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        require(address(hook) == predicted, "hook address mismatch");

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(FULL_RANGE_LIQUIDITY)),
                salt: 0
            }),
            ""
        );
    }

    function _swap(bool zeroForOne, int256 amountSpecified, uint160 limit, uint256 value)
        internal
        returns (BalanceDelta)
    {
        return swapRouter.swap{value: value}(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    /// @dev PANIC is currency1, so a PANIC drawdown of d raises price1/0 by 1/(1-d).
    function _sqrtPriceAtDrawdown(uint160 refSqrt, uint256 drawdownBps) internal pure returns (uint160) {
        uint256 ref2 = uint256(refSqrt) * uint256(refSqrt);
        return uint160(_sqrt(ref2 * 10_000 / (10_000 - drawdownBps)) + 1);
    }

    function test_partialFillBuyIsChargedOnTheRequestedInputNotTheConsumedInput() public {
        // Next block: dump PANIC until the price sits 10% below the (still untouched) reference.
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);
        uint160 limit = _sqrtPriceAtDrawdown(hook.referenceSqrtPriceX96(), 1000);
        _swap(false, -int256(1e26), limit, 0);
        assertGe(hook.currentDrawdownBps(), 500, "down: buys are fee-bearing");

        // A buyer submits an exact-input buy of 100 ETH with a price limit one tick past the current
        // price, so the pool consumes only a sliver of it.
        (uint160 sqrtBefore, int24 tickBefore,,) = IPoolManager(address(manager)).getSlot0(poolId);
        uint160 buyLimit = TickMath.getSqrtPriceAtTick(tickBefore - 1);
        assertLt(buyLimit, sqrtBefore, "the limit is strictly past the current price");

        uint256 feesBefore = hook.totalAccruedFees();
        BalanceDelta d = _swap(true, -int256(100 ether), buyLimit, 100 ether);
        uint256 fee = hook.totalAccruedFees() - feesBefore;

        // What the swapper actually paid in ETH, and how much of that reached the pool.
        uint256 paid = uint256(uint128(-d.amount0()));
        uint256 consumedByPool = paid - fee;

        emit log_named_uint("ETH requested      ", 100 ether);
        emit log_named_uint("ETH consumed by pool", consumedByPool);
        emit log_named_uint("hook fee charged    ", fee);
        emit log_named_uint("fee as bps of pool input", fee * 10_000 / consumedByPool);

        assertLt(consumedByPool, 1 ether, "only a sliver of the order filled");
        // The brief: buys pay 1% of the input when down. The input is what the pool took, not what the
        // user offered. A partial fill must pay 1% of the consumed input (+1 wei rounding allowance).
        assertLe(fee, consumedByPool * 100 / 10_000 + 1, "fee must be 1% of the input actually swapped");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The split-sell discount from a NOT-down start.
contract SplitSellProofTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;
    uint128 constant FULL_RANGE_LIQUIDITY = 1e22;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        require(address(hook) == predicted, "hook address mismatch");

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(FULL_RANGE_LIQUIDITY)),
                salt: 0
            }),
            ""
        );
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);
    }

    function _sell(int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return swapRouter.swap(
            key,
            SwapParams({zeroForOne: false, amountSpecified: amount, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    function _sqrtPriceAtDrawdown(uint160 refSqrt, uint256 drawdownBps) internal pure returns (uint160) {
        uint256 ref2 = uint256(refSqrt) * uint256(refSqrt);
        return uint160(_sqrt(ref2 * 10_000 / (10_000 - drawdownBps)) + 1);
    }

    function test_splittingFromFlatPaysLessTaxThanOneSell() public {
        uint160 ref = hook.referenceSqrtPriceX96();
        uint160 target = _sqrtPriceAtDrawdown(ref, 2000);

        // One sell from flat to 20% down.
        uint256 snap = vm.snapshotState();
        uint256 before = hook.totalAccruedFees();
        BalanceDelta single = _sell(-int256(1e26), target);
        uint256 singleFee = hook.totalAccruedFees() - before;
        uint256 panicSold = uint256(uint128(-single.amount1()));
        uint256 singleGross = uint256(uint128(single.amount0())) + singleFee;
        emit log_named_uint("single sell: PANIC sold    ", panicSold);
        emit log_named_uint("single sell: gross ETH out ", singleGross);
        emit log_named_uint("single sell: hook fee      ", singleFee);
        emit log_named_uint("single sell: fee bps       ", singleFee * 10_000 / singleGross);
        vm.revertToState(snap);

        // The same PANIC in ten equal slices, same block, same reference.
        before = hook.totalAccruedFees();
        uint256 splitGross;
        for (uint256 i = 0; i < 10; i++) {
            uint256 pieceBefore = hook.totalAccruedFees();
            BalanceDelta piece = _sell(-int256(panicSold / 10), TickMath.MAX_SQRT_PRICE - 1);
            uint256 pieceFee = hook.totalAccruedFees() - pieceBefore;
            splitGross += uint256(uint128(piece.amount0())) + pieceFee;
            emit log_named_uint("slice drawdown bps after", hook.currentDrawdownBps());
            emit log_named_uint("slice fee bps           ", pieceFee * 10_000 / (uint256(uint128(piece.amount0())) + pieceFee));
        }
        uint256 splitFee = hook.totalAccruedFees() - before;
        emit log_named_uint("split: gross ETH out       ", splitGross);
        emit log_named_uint("split: total hook fee      ", splitFee);
        emit log_named_uint("split: fee bps             ", splitFee * 10_000 / splitGross);
        emit log_named_uint("split saves (ETH wei)      ", singleFee - splitFee);

        // The brief: splitting one large sell into 10 small sells pays at least as much total tax.
        assertGe(splitFee + 10, singleFee, "ten slices from a flat start pay less tax than one sell");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice An exact-input buy while the price is down pays the 1% hook fee on the whole specified input,
/// even when the swapper's price limit lets the pool consume only a small part of it. The fee is then
/// far above 1% of the paired currency actually traded, and above the 30% hook-fee ceiling.
contract ExactInputBuyFeeOnUnfilledInputTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        assertEq(address(hook), predicted);

        // PANIC / native ETH: ETH is currency0, PANIC is currency1.
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(1e22)),
                salt: 0
            }),
            ""
        );
    }

    function _swap(bool zeroForOne, int256 amountSpecified, uint160 limit) internal returns (BalanceDelta) {
        uint256 value = 0;
        if (zeroForOne) value = amountSpecified < 0 ? uint256(-amountSpecified) : 1e26;
        return swapRouter.swap{value: value}(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_exactInputBuyWithPriceLimitPaysFeeOnlyOnWhatThePoolConsumed() public {
        // Put the pool about 10% down so buys are fee-bearing (1%). PANIC is currency1, so a sell pushes
        // price1/0 up: a sqrt limit of 1.054 * 2^96 lands PANIC about 10% below the reference.
        uint160 downLimit = uint160(uint256(SQRT_PRICE_1_1) * 1054 / 1000);
        _swap(false, -int256(1e26), downLimit);
        assertGe(hook.currentDrawdownBps(), 500, "down: buys pay 1%");

        // Exact-input buy of 100 ETH, but with a price limit just 0.01% away, so the pool can only
        // consume a small part of the input (about 1 ETH in this pool).
        (uint160 sqrtNow,,,) = IPoolManager(address(manager)).getSlot0(poolId);
        uint160 limit = sqrtNow - sqrtNow / 10_000;
        uint256 specified = 100 ether;

        uint256 feesBefore = hook.totalAccruedFees();
        // A fix may either charge 1% of the input actually consumed, or refuse a fee-bearing exact-input
        // buy that cannot be filled completely (as exact-output sells are refused). Both are accepted here;
        // what is not acceptable is a successful swap that charges more than 1% of what was traded.
        (bool ok, bytes memory ret) = address(this).call(abi.encodeCall(this.doLimitedBuy, (specified, limit)));
        if (!ok) {
            assertEq(hook.totalAccruedFees(), feesBefore, "a refused swap charges nothing");
            return;
        }
        BalanceDelta d = abi.decode(ret, (BalanceDelta));
        uint256 fee = hook.totalAccruedFees() - feesBefore;

        uint256 paidTotal = uint256(-int256(d.amount0()));
        uint256 poolInput = paidTotal - fee;
        assertLt(poolInput, specified / 10, "the limit stopped the fill early: most of the input was not swapped");

        // Expected: 1% of the paired currency actually traded (the pool's input), as the brief says
        // "1% ... from the input". Actual: 1% of the whole specified amount (1 ETH on a ~1 ETH fill).
        assertLe(fee, poolInput * 100 / 10_000 + 1, "hook fee must be 1% of the input actually swapped");
        assertLe(fee * 10_000, poolInput * 3000, "hook fee must never exceed 30% of the amount traded");
    }

    function doLimitedBuy(uint256 specified, uint160 limit) external returns (BalanceDelta) {
        require(msg.sender == address(this));
        return _swap(true, -int256(specified), limit);
    }
}

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

import {Test, console2} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

contract SplitFromFlatTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);
        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(1e22)),
                salt: 0
            }),
            ""
        );
    }

    function _sell(uint256 amount) internal returns (BalanceDelta) {
        return swapRouter.swap(
            key,
            SwapParams({zeroForOne: false, amountSpecified: -int256(amount), sqrtPriceLimitX96: TickMath.MAX_SQRT_PRICE - 1}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_measureSplitFromFlat() public {
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);
        assertEq(hook.currentDrawdownBps(), 0);
        uint256 amount = 1200 ether; // lands around 20% down in this pool

        uint256 snap = vm.snapshotState();
        BalanceDelta d = _sell(amount);
        uint256 singleFee = hook.totalAccruedFees();
        uint256 singleGross = uint256(int256(d.amount0())) + singleFee;
        uint256 singleDd = hook.currentDrawdownBps();
        vm.revertToState(snap);

        uint256 splitGross;
        for (uint256 i = 0; i < 10; i++) {
            BalanceDelta p = _sell(amount / 10);
            splitGross += uint256(int256(p.amount0()));
        }
        uint256 splitFee = hook.totalAccruedFees();
        splitGross += splitFee;
        uint256 splitDd = hook.currentDrawdownBps();

        console2.log("single sell: drawdown bps", singleDd);
        console2.log("single sell: gross ETH out", singleGross);
        console2.log("single sell: fee", singleFee);
        console2.log("split x10: drawdown bps", splitDd);
        console2.log("split x10: gross ETH out", splitGross);
        console2.log("split x10: fee", splitFee);
        assertGe(splitFee + 10, singleFee, "splitting into ten from a flat price must pay at least as much");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Required property: splitting one large sell into 10 small sells pays at least as much total tax.
/// Starting from a flat price (drawdown 0), one sell that ends 20% down pays 20% of its output, while the
/// same PANIC sold in ten slices in the same block pays the low tiers on the early slices.
contract SplitFlatTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;
    address oracleFund = makeAddr("oracleFund");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode =
            abi.encodePacked(type(PanicHook).creationCode, abi.encode(address(manager), address(panic), oracleFund));
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), oracleFund);
        assertEq(address(hook), predicted);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(1e22)),
                salt: 0
            }),
            ""
        );
        // Leave the launch block so the comparison is in an ordinary block.
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);
    }

    function _sell(int256 amountSpecified, uint160 limit) internal returns (BalanceDelta) {
        return swapRouter.swap(
            key,
            SwapParams({zeroForOne: false, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_splittingAFlatStartDumpIntoTenPaysLessTax() public {
        assertEq(hook.currentDrawdownBps(), 0, "starts flat");

        // Find the PANIC amount that moves the price from flat to 20% down with one sell.
        uint256 snap = vm.snapshotState();
        uint160 ref = hook.referenceSqrtPriceX96();
        uint256 ref2 = uint256(ref) * uint256(ref);
        uint160 limit = uint160(_sqrt(ref2 * 10_000 / 8_000) + 1);
        BalanceDelta probe = _sell(-int256(1e26), limit);
        uint256 amount = uint256(-int256(probe.amount1()));
        vm.revertToState(snap);

        // One sell of `amount`: judged 20% down, pays 20% of the gross output.
        snap = vm.snapshotState();
        uint256 before = hook.totalAccruedFees();
        BalanceDelta single = _sell(-int256(amount), TickMath.MAX_SQRT_PRICE - 1);
        uint256 singleFee = hook.totalAccruedFees() - before;
        uint256 singleGross = uint256(int256(single.amount0())) + singleFee;
        assertGe(hook.currentDrawdownBps(), 2000);
        assertEq(singleFee, singleGross * 2000 / 10_000, "one sell pays 20%");
        vm.revertToState(snap);

        // The same `amount` in ten slices, same block, same frozen reference.
        before = hook.totalAccruedFees();
        uint256 splitGross;
        for (uint256 i = 0; i < 10; i++) {
            uint256 feeBefore = hook.totalAccruedFees();
            BalanceDelta piece = _sell(-int256(amount / 10), TickMath.MAX_SQRT_PRICE - 1);
            splitGross += uint256(int256(piece.amount0())) + (hook.totalAccruedFees() - feeBefore);
        }
        uint256 splitFee = hook.totalAccruedFees() - before;
        assertGe(hook.currentDrawdownBps() + 5, 2000, "same end price, give or take pool rounding");

        emit log_named_uint("single sell: gross ETH output", singleGross);
        emit log_named_uint("single sell: hook fee", singleFee);
        emit log_named_uint("ten slices: gross ETH output", splitGross);
        emit log_named_uint("ten slices: hook fee", splitFee);
        emit log_named_uint("tax saved by splitting (ETH wei)", singleFee - splitFee);
        assertGe(splitFee + 10, singleFee, "ten small sells must pay at least the single sell's tax");
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice An exact-input buy that only partially fills (price limit reached) is charged the 1% hook fee on
/// the whole specified input, not on the amount the pool actually consumed. The fee can exceed the amount
/// traded, breaking the "hook fee never exceeds 30%" guarantee for that trade.
contract PartialFillBuyFeeTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;
    address oracleFund = makeAddr("oracleFund");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode =
            abi.encodePacked(type(PanicHook).creationCode, abi.encode(address(manager), address(panic), oracleFund));
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), oracleFund);
        assertEq(address(hook), predicted);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(1e22)),
                salt: 0
            }),
            ""
        );
    }

    function _sqrtPrice() internal view returns (uint160 p) {
        (p,,,) = IPoolManager(address(manager)).getSlot0(poolId);
    }

    function _swap(bool zeroForOne, int256 amountSpecified, uint160 limit, uint256 value)
        internal
        returns (BalanceDelta)
    {
        return swapRouter.swap{value: value}(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_partialFillBuyIsChargedOnTheUnfilledInput() public {
        // Push the pool 10% down so buys are fee-bearing (1%).
        uint160 ref = hook.referenceSqrtPriceX96();
        uint256 ref2 = uint256(ref) * uint256(ref);
        uint160 downLimit = uint160(_sqrt(ref2 * 10_000 / 9_000) + 1);
        _swap(false, -int256(1e26), downLimit, 0);
        assertGe(hook.currentDrawdownBps(), 500, "down");

        // A dip buyer sends a 100 ETH exact-input buy with a price limit that lets the pool absorb only a
        // small part of it (a limit buy: "buy with up to 100 ETH, but not above this price").
        uint160 current = _sqrtPrice();
        uint160 limit = current - uint160(uint256(current) / 1_000_000); // a 0.0001% move in sqrt price
        uint256 ethBefore = address(this).balance;
        uint256 feesBefore = hook.totalAccruedFees();
        BalanceDelta d = _swap(true, -int256(100 ether), limit, 100 ether);

        uint256 paidTotal = ethBefore - address(this).balance;
        uint256 fee = hook.totalAccruedFees() - feesBefore;
        uint256 poolInput = paidTotal - fee;

        emit log_named_uint("eth consumed by the pool", poolInput);
        emit log_named_uint("hook fee charged", fee);
        emit log_named_uint("total paid", paidTotal);
        assertEq(fee, 1 ether, "1% of the 100 ETH specified, though only a sliver filled");
        assertLt(poolInput, 1 ether, "the pool took far less than the fee");
        assertEq(_sqrtPrice(), limit, "the swap stopped at the price limit");
        assertGt(d.amount1(), 0);

        // The guarantee the brief states: the hook fee never exceeds 30% of the amount it is taken from.
        assertLe(fee * 10_000, poolInput * 3000, "hook fee exceeds 30% of the paired input actually traded");
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Vm} from "forge-std/Vm.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The 30% LP share is paid by `PoolManager.donate` to whoever is in range when the permissionless
/// `donateToLiquidityProviders()` runs. Because the caller picks the moment, anyone can add a one-spacing-wide
/// position at the current tick, donate, and remove it in one transaction, taking almost the whole bucket
/// from the liquidity that actually served the taxed trades.
contract JitDonateTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;
    uint128 constant HONEST_LIQUIDITY = 1e22;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;
    address oracleFund = makeAddr("oracleFund");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode =
            abi.encodePacked(type(PanicHook).creationCode, abi.encode(address(manager), address(panic), oracleFund));
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), oracleFund);
        assertEq(address(hook), predicted);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        // The honest LP: full range, in place for every taxed trade.
        _modify(TickMath.minUsableTick(TICK_SPACING), TickMath.maxUsableTick(TICK_SPACING), int256(uint256(HONEST_LIQUIDITY)));
    }

    function _modify(int24 lower, int24 upper, int256 liquidityDelta) internal returns (BalanceDelta) {
        uint256 value = liquidityDelta > 0 ? 1e26 : 0;
        return lpRouter.modifyLiquidity{value: value}(
            key, ModifyLiquidityParams({tickLower: lower, tickUpper: upper, liquidityDelta: liquidityDelta, salt: 0}), ""
        );
    }

    function _tick() internal view returns (int24 t) {
        (, t,,) = IPoolManager(address(manager)).getSlot0(poolId);
    }

    /// @dev Sum of `feeAmount` in every HookFeeCharged event recorded since `vm.recordLogs()`.
    function _hookFeesCharged() internal returns (uint256 total) {
        bytes32 sig = keccak256("HookFeeCharged(address,bool,uint256,uint256,uint256)");
        Vm.Log[] memory logs = vm.getRecordedLogs();
        for (uint256 i = 0; i < logs.length; i++) {
            if (logs[i].emitter != address(hook) || logs[i].topics[0] != sig) continue;
            (,,, uint256 amount) = abi.decode(logs[i].data, (bool, uint256, uint256, uint256));
            total += amount;
        }
    }

    function test_jitPositionCapturesTheLpDonation() public {
        // A 20% crash, served entirely by the honest full-range LP, charges a 20% hook fee.
        vm.recordLogs();
        uint160 ref = hook.referenceSqrtPriceX96();
        uint256 ref2 = uint256(ref) * uint256(ref);
        uint160 downLimit = uint160(_sqrt(ref2 * 10_000 / 8_000) + 1);
        swapRouter.swap(
            key,
            SwapParams({zeroForOne: false, amountSpecified: -int256(1e26), sqrtPriceLimitX96: downLimit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
        uint256 lpShare = _hookFeesCharged() * 3000 / 10_000;
        assertGt(lpShare, 0, "the crash produced an LP share");

        // Attacker (this contract as a JIT LP): a one-spacing-wide position around the current tick, the
        // permissionless donate call, and removal, all in one transaction.
        int24 t = _tick();
        int24 lower = t >= 0 ? (t / TICK_SPACING) * TICK_SPACING : -((-t + TICK_SPACING - 1) / TICK_SPACING) * TICK_SPACING;
        int24 upper = lower + TICK_SPACING;
        uint128 jit = 1e25;

        uint256 ethBefore = address(this).balance;
        uint256 panicBefore = panic.balanceOf(address(this));
        _modify(lower, upper, int256(uint256(jit)));
        try hook.donateToLiquidityProviders() {} catch {}
        _modify(lower, upper, -int256(uint256(jit)));
        uint256 captured = address(this).balance + 10 - ethBefore; // 10 wei allowance for position rounding
        assertGe(panic.balanceOf(address(this)) + 10, panicBefore, "PANIC round-trips");

        // What the honest LP, which served the taxed trade, collects of the LP share.
        BalanceDelta honest = _modify(TickMath.minUsableTick(TICK_SPACING), TickMath.maxUsableTick(TICK_SPACING), 0);
        uint256 honestEth = uint256(int256(honest.amount0()));

        emit log_named_uint("LP share of the hook fee", lpShare);
        emit log_named_uint("captured by the one-transaction JIT position", captured);
        emit log_named_uint("collected by the honest LP that served the trade", honestEth);
        assertLt(captured * 2, lpShare, "a one-transaction JIT position captured most of the LP share");
        assertGt(honestEth * 2, lpShare, "the LP that served every taxed swap got almost none of it");
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PanicHook} from "src/PanicHook.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
contract SplitSellProof is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    PanicHook hook;
    PanicMonkeys panic;
    PoolKey key;
    receive() external payable {}
    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        vm.deal(address(this), 1_000_000 ether);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        bytes memory code = abi.encodePacked(type(PanicHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF)));
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, code, 0, 1_000_000);
        hook = new PanicHook{salt:salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(panic)), 12_500, 100, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(false, SwapParams(false, 0, 0)));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (bool isSwap, SwapParams memory params) = abi.decode(data, (bool, SwapParams));
        BalanceDelta delta;
        if (isSwap) delta = manager.swap(key, params, "");
        else (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
            TickMath.minUsableTick(100), TickMath.maxUsableTick(100), 10_000 ether, 0), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta) internal {
        if (delta > 0) manager.take(currency, address(this), uint256(int256(delta)));
        if (delta < 0) {
            uint256 owed = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) manager.settle{value:owed}();
            else {
                manager.sync(currency);
                panic.transfer(address(manager), owed);
                manager.settle();
            }
        }
    }
    function swap(bool direction, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, SwapParams(direction, amount, limit))), (BalanceDelta));
    }
    function sell(uint256 amount) internal returns (BalanceDelta) {
        return swap(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1);
    }
    function test_tenSellsMustPayAtLeastTheSingleSellTax() public {
        uint256 snapshot = vm.snapshotState();
        sell(1_200 ether);
        uint256 singleFee = hook.totalAccruedFees();
        uint256 endDrawdown = hook.currentDrawdownBps();
        assertGe(endDrawdown, 1_500);
        assertLt(endDrawdown, 3_000);
        assertTrue(vm.revertToState(snapshot));
        for (uint256 i; i < 10; ++i) sell(120 ether);
        uint256 splitFee = hook.totalAccruedFees();
        assertApproxEqAbs(hook.currentDrawdownBps(), endDrawdown, 1);
        emit log_named_uint("single fee", singleFee);
        emit log_named_uint("split fee", splitFee);
        assertGe(splitFee, singleFee, "splitting the same sell must not reduce tax");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PanicHook} from "src/PanicHook.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
contract PartialBuyProof is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    PanicHook hook;
    PanicMonkeys panic;
    PoolKey key;
    receive() external payable {}
    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        vm.deal(address(this), 1_000_000 ether);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        bytes memory code = abi.encodePacked(type(PanicHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF)));
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, code, 0, 1_000_000);
        hook = new PanicHook{salt:salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(panic)), 12_500, 100, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(false, SwapParams(false, 0, 0)));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (bool isSwap, SwapParams memory params) = abi.decode(data, (bool, SwapParams));
        BalanceDelta delta;
        if (isSwap) delta = manager.swap(key, params, "");
        else (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
            TickMath.minUsableTick(100), TickMath.maxUsableTick(100), 10_000 ether, 0), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta) internal {
        if (delta > 0) manager.take(currency, address(this), uint256(int256(delta)));
        if (delta < 0) {
            uint256 owed = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) manager.settle{value:owed}();
            else {
                manager.sync(currency);
                panic.transfer(address(manager), owed);
                manager.settle();
            }
        }
    }
    function swap(bool direction, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, SwapParams(direction, amount, limit))), (BalanceDelta));
    }
    function sell(uint256 amount) internal returns (BalanceDelta) {
        return swap(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1);
    }
    function test_partialBuyFeeCannotExceedThirtyPercentOfActualInput() public {
        sell(1_200 ether);
        assertGe(hook.currentDrawdownBps(), 500);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        uint256 beforeFees = hook.totalAccruedFees();
        uint256 beforeBalance = address(this).balance;
        BalanceDelta delta = swap(true, -int256(1_000 ether), price - 1);
        uint256 fee = hook.totalAccruedFees() - beforeFees;
        uint256 paid = beforeBalance - address(this).balance;
        assertEq(paid, uint256(-int256(delta.amount0())));
        emit log_named_uint("actual input paid", paid);
        emit log_named_uint("hook fee", fee);
        assertLe(fee * 10_000, paid * 3_000, "hook fee exceeds the 30% hard cap on actual input");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PanicHook} from "src/PanicHook.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
contract BuybackFeeProof is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    PanicHook hook;
    PanicMonkeys panic;
    PoolKey key;
    receive() external payable {}
    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        vm.deal(address(this), 1_000_000 ether);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        bytes memory code = abi.encodePacked(type(PanicHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF)));
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, code, 0, 1_000_000);
        hook = new PanicHook{salt:salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(panic)), 12_500, 100, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(false, SwapParams(false, 0, 0)));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (bool isSwap, SwapParams memory params) = abi.decode(data, (bool, SwapParams));
        BalanceDelta delta;
        if (isSwap) delta = manager.swap(key, params, "");
        else (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
            TickMath.minUsableTick(100), TickMath.maxUsableTick(100), 10_000 ether, 0), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta) internal {
        if (delta > 0) manager.take(currency, address(this), uint256(int256(delta)));
        if (delta < 0) {
            uint256 owed = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) manager.settle{value:owed}();
            else {
                manager.sync(currency);
                panic.transfer(address(manager), owed);
                manager.settle();
            }
        }
    }
    function swap(bool direction, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, SwapParams(direction, amount, limit))), (BalanceDelta));
    }
    function sell(uint256 amount) internal returns (BalanceDelta) {
        return swap(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1);
    }
    function test_buybackInADipMustAlsoPayTheOnePercentFee() public {
        sell(1_200 ether);
        assertGe(hook.currentDrawdownBps(), 500);
        uint256 oracleBefore = hook.oracleFundBucket();
        uint256 donationBefore = hook.donationBucket();
        (uint256 spent,) = hook.buybackAndBurn();
        assertGt(spent, 0);
        assertGt(hook.oracleFundBucket(), oracleBefore, "no address exemption: buyback must fund oracle share");
        assertGt(hook.donationBucket(), donationBefore, "buyback must fund LP share");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice An exact-input buy while the price is down pays the 1% hook fee on the whole specified input,
/// even when the swapper's price limit lets the pool consume only a small part of it. The fee is then
/// far above 1% of the paired currency actually traded, and above the 30% hook-fee ceiling.
contract ExactInputBuyFeeOnUnfilledInputTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        assertEq(address(hook), predicted);

        // PANIC / native ETH: ETH is currency0, PANIC is currency1.
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(1e22)),
                salt: 0
            }),
            ""
        );
    }

    function _swap(bool zeroForOne, int256 amountSpecified, uint160 limit) internal returns (BalanceDelta) {
        uint256 value = 0;
        if (zeroForOne) value = amountSpecified < 0 ? uint256(-amountSpecified) : 1e26;
        return swapRouter.swap{value: value}(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_exactInputBuyWithPriceLimitPaysFeeOnlyOnWhatThePoolConsumed() public {
        // Put the pool about 10% down so buys are fee-bearing (1%). PANIC is currency1, so a sell pushes
        // price1/0 up: a sqrt limit of 1.054 * 2^96 lands PANIC about 10% below the reference.
        uint160 downLimit = uint160(uint256(SQRT_PRICE_1_1) * 1054 / 1000);
        _swap(false, -int256(1e26), downLimit);
        assertGe(hook.currentDrawdownBps(), 500, "down: buys pay 1%");

        // Exact-input buy of 100 ETH, but with a price limit just 0.01% away, so the pool can only
        // consume a small part of the input (about 1 ETH in this pool).
        (uint160 sqrtNow,,,) = IPoolManager(address(manager)).getSlot0(poolId);
        uint160 limit = sqrtNow - sqrtNow / 10_000;
        uint256 specified = 100 ether;

        uint256 feesBefore = hook.totalAccruedFees();
        // A fix may either charge 1% of the input actually consumed, or refuse a fee-bearing exact-input
        // buy that cannot be filled completely (as exact-output sells are refused). Both are accepted here;
        // what is not acceptable is a successful swap that charges more than 1% of what was traded.
        (bool ok, bytes memory ret) = address(this).call(abi.encodeCall(this.doLimitedBuy, (specified, limit)));
        if (!ok) {
            assertEq(hook.totalAccruedFees(), feesBefore, "a refused swap charges nothing");
            return;
        }
        BalanceDelta d = abi.decode(ret, (BalanceDelta));
        uint256 fee = hook.totalAccruedFees() - feesBefore;

        uint256 paidTotal = uint256(-int256(d.amount0()));
        uint256 poolInput = paidTotal - fee;
        assertLt(poolInput, specified / 10, "the limit stopped the fill early: most of the input was not swapped");

        // Expected: 1% of the paired currency actually traded (the pool's input), as the brief says
        // "1% ... from the input". Actual: 1% of the whole specified amount (1 ETH on a ~1 ETH fill).
        assertLe(fee, poolInput * 100 / 10_000 + 1, "hook fee must be 1% of the input actually swapped");
        assertLe(fee * 10_000, poolInput * 3000, "hook fee must never exceed 30% of the amount traded");
    }

    function doLimitedBuy(uint256 specified, uint160 limit) external returns (BalanceDelta) {
        require(msg.sender == address(this));
        return _swap(true, -int256(specified), limit);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.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 {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The 30% LP share is paid by a permissionless `donateToLiquidityProviders()` to whoever is in
/// range at the moment of the call. Anyone can add a huge single-tick position, call it, and remove the
/// position in one transaction, taking essentially the whole bucket away from the real LPs.
contract JitDonationTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 100;
    uint128 constant FULL_RANGE_LIQUIDITY = 1e22;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;
    PoolId poolId;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF))
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        require(address(hook) == predicted, "hook address mismatch");

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        poolId = key.toId();
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        // The honest LP: full range.
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(uint256(FULL_RANGE_LIQUIDITY)),
                salt: 0
            }),
            ""
        );
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }

    function _sqrtPriceAtDrawdown(uint160 refSqrt, uint256 drawdownBps) internal pure returns (uint160) {
        uint256 ref2 = uint256(refSqrt) * uint256(refSqrt);
        return uint160(_sqrt(ref2 * 10_000 / (10_000 - drawdownBps)) + 1);
    }

    function test_jitLiquidityCapturesTheWholeLpDonation() public {
        // A 20% crash fills the donation bucket.
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 12);
        swapRouter.swap(
            key,
            SwapParams({
                zeroForOne: false,
                amountSpecified: -int256(1e26),
                sqrtPriceLimitX96: _sqrtPriceAtDrawdown(hook.referenceSqrtPriceX96(), 2000)
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
        uint256 bucket = hook.donationBucket();
        assertGt(bucket, 0);

        // Attacker, in one transaction: add a huge position covering only the current tick spacing,
        // call the permissionless donate, remove the position.
        address attacker = makeAddr("attacker");
        vm.deal(attacker, 1e27);
        panic.transfer(attacker, 1e26);
        vm.startPrank(attacker);
        panic.approve(address(lpRouter), type(uint256).max);

        (, int24 tick,,) = IPoolManager(address(manager)).getSlot0(poolId);
        int24 lower = (tick / TICK_SPACING) * TICK_SPACING;
        if (tick < 0 && tick % TICK_SPACING != 0) lower -= TICK_SPACING;
        int24 upper = lower + TICK_SPACING;
        uint128 jit = FULL_RANGE_LIQUIDITY * 10_000;

        uint256 ethBefore = attacker.balance;
        uint256 panicBefore = panic.balanceOf(attacker);
        lpRouter.modifyLiquidity{value: 1e26}(
            key,
            ModifyLiquidityParams({tickLower: lower, tickUpper: upper, liquidityDelta: int256(uint256(jit)), salt: 0}),
            ""
        );
        uint256 ethAfterAdd = attacker.balance;
        // The router keeps unspent msg.value; measure what the position actually cost.
        uint256 routerEth = address(lpRouter).balance;

        (bool ok,) = address(hook).call(abi.encodeWithSignature("donateToLiquidityProviders()"));
        ok; // may be a no-op or revert on a fixed contract; what matters is where the money went

        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({tickLower: lower, tickUpper: upper, liquidityDelta: -int256(uint256(jit)), salt: 0}),
            ""
        );
        vm.stopPrank();

        int256 ethGain = int256(attacker.balance + routerEth) - int256(ethBefore);
        int256 panicGain = int256(panic.balanceOf(attacker)) - int256(panicBefore);
        ethAfterAdd;

        emit log_named_uint("donation bucket (ETH wei)", bucket);
        emit log_named_int("attacker ETH gain       ", ethGain);
        emit log_named_int("attacker PANIC change   ", panicGain);
        emit log_named_int("captured bps of bucket  ", ethGain * 10_000 / int256(bucket));

        // The LP share is meant for the pool's liquidity providers. A flash position that exists only
        // for the donate call must not be able to take the bulk of it.
        assertLt(ethGain, int256(bucket / 2), "a JIT position captured most of the LP donation");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PanicHook} from "src/PanicHook.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
contract SplitSellProof is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    PanicHook hook;
    PanicMonkeys panic;
    PoolKey key;
    receive() external payable {}
    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        vm.deal(address(this), 1_000_000 ether);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        bytes memory code = abi.encodePacked(type(PanicHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF)));
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, code, 0, 1_000_000);
        hook = new PanicHook{salt:salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(panic)), 12_500, 100, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(false, SwapParams(false, 0, 0)));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (bool isSwap, SwapParams memory params) = abi.decode(data, (bool, SwapParams));
        BalanceDelta delta;
        if (isSwap) delta = manager.swap(key, params, "");
        else (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
            TickMath.minUsableTick(100), TickMath.maxUsableTick(100), 10_000 ether, 0), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta) internal {
        if (delta > 0) manager.take(currency, address(this), uint256(int256(delta)));
        if (delta < 0) {
            uint256 owed = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) manager.settle{value:owed}();
            else {
                manager.sync(currency);
                panic.transfer(address(manager), owed);
                manager.settle();
            }
        }
    }
    function swap(bool direction, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, SwapParams(direction, amount, limit))), (BalanceDelta));
    }
    function sell(uint256 amount) internal returns (BalanceDelta) {
        return swap(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1);
    }
    function test_tenSellsMustPayAtLeastTheSingleSellTax() public {
        uint256 snapshot = vm.snapshotState();
        sell(1_200 ether);
        uint256 singleFee = hook.totalAccruedFees();
        uint256 endDrawdown = hook.currentDrawdownBps();
        assertGe(endDrawdown, 1_500);
        assertLt(endDrawdown, 3_000);
        assertTrue(vm.revertToState(snapshot));
        for (uint256 i; i < 10; ++i) sell(120 ether);
        uint256 splitFee = hook.totalAccruedFees();
        assertApproxEqAbs(hook.currentDrawdownBps(), endDrawdown, 1);
        emit log_named_uint("single fee", singleFee);
        emit log_named_uint("split fee", splitFee);
        assertGe(splitFee, singleFee, "splitting the same sell must not reduce tax");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PanicHook} from "src/PanicHook.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
contract SplitSellJudge is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    PanicHook hook;
    PanicMonkeys panic;
    PoolKey key;
    receive() external payable {}
    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        vm.deal(address(this), 1_000_000 ether);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        bytes memory code = abi.encodePacked(type(PanicHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF)));
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, code, 0, 1_000_000);
        hook = new PanicHook{salt:salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(panic)), 12_500, 100, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(false, SwapParams(false, 0, 0)));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (bool isSwap, SwapParams memory params) = abi.decode(data, (bool, SwapParams));
        BalanceDelta delta;
        if (isSwap) delta = manager.swap(key, params, "");
        else (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
            TickMath.minUsableTick(100), TickMath.maxUsableTick(100), 10_000 ether, 0), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta) internal {
        if (delta > 0) manager.take(currency, address(this), uint256(int256(delta)));
        if (delta < 0) {
            uint256 owed = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) manager.settle{value:owed}();
            else {
                manager.sync(currency);
                panic.transfer(address(manager), owed);
                manager.settle();
            }
        }
    }
    function swap(bool direction, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, SwapParams(direction, amount, limit))), (BalanceDelta));
    }
    function sell(uint256 amount) internal returns (BalanceDelta) {
        return swap(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1);
    }
    function test_tenSellsMustPayAtLeastTheSingleSellTax() public {
        uint256 snapshot = vm.snapshotState();
        sell(1_200 ether);
        uint256 singleFee = hook.totalAccruedFees() + hook.totalDonated();
        uint256 endDrawdown = hook.currentDrawdownBps();
        assertGe(endDrawdown, 1_500);
        assertLt(endDrawdown, 3_000);
        assertTrue(vm.revertToState(snapshot));
        for (uint256 i; i < 10; ++i) sell(120 ether);
        uint256 splitFee = hook.totalAccruedFees() + hook.totalDonated();
        assertApproxEqAbs(hook.currentDrawdownBps(), endDrawdown, 1);
        emit log_named_uint("single fee", singleFee);
        emit log_named_uint("split fee", splitFee);
        assertGe(splitFee, singleFee, "splitting the same sell must not reduce tax");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PanicHook} from "src/PanicHook.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
contract SplitSellJudge is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    PanicHook hook;
    PanicMonkeys panic;
    PoolKey key;
    receive() external payable {}
    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        vm.deal(address(this), 1_000_000 ether);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        bytes memory code = abi.encodePacked(type(PanicHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(panic), address(0xBEEF)));
        (, bytes32 salt) = HookMiner.find(address(this), HookFlags.PANIC_HOOK, code, 0, 1_000_000);
        hook = new PanicHook{salt:salt}(IPoolManager(address(manager)), address(panic), address(0xBEEF));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(panic)), 12_500, 100, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(false, SwapParams(false, 0, 0)));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (bool isSwap, SwapParams memory params) = abi.decode(data, (bool, SwapParams));
        BalanceDelta delta;
        if (isSwap) delta = manager.swap(key, params, "");
        else (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
            TickMath.minUsableTick(100), TickMath.maxUsableTick(100), 10_000 ether, 0), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta) internal {
        if (delta > 0) manager.take(currency, address(this), uint256(int256(delta)));
        if (delta < 0) {
            uint256 owed = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) manager.settle{value:owed}();
            else {
                manager.sync(currency);
                panic.transfer(address(manager), owed);
                manager.settle();
            }
        }
    }
    function swap(bool direction, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, SwapParams(direction, amount, limit))), (BalanceDelta));
    }
    function sell(uint256 amount) internal returns (BalanceDelta) {
        return swap(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1);
    }
    function test_tenSellsMustPayAtLeastTheSingleSellTax() public {
        uint256 snapshot = vm.snapshotState();
        sell(1_200 ether);
        uint256 singleFee = hook.totalAccruedFees() + hook.totalDonated();
        uint256 endDrawdown = hook.currentDrawdownBps();
        assertGe(endDrawdown, 1_500);
        assertLt(endDrawdown, 3_000);
        assertTrue(vm.revertToState(snapshot));
        for (uint256 i; i < 10; ++i) sell(120 ether);
        uint256 splitFee = hook.totalAccruedFees() + hook.totalDonated();
        assertApproxEqAbs(hook.currentDrawdownBps(), endDrawdown, 1);
        emit log_named_uint("single fee", singleFee);
        emit log_named_uint("split fee", splitFee);
        assertGe(splitFee, singleFee, "splitting the same sell must not reduce tax");
    }
}