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

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

contract PlainERC20 is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

/// @dev A router that pays before swapping: sync -> transfer -> swap -> settle. v4 only requires that
/// the balance change between sync and settle equals the payment; the hook's take breaks that.
contract PrepayRouter is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }

    function swap(PoolKey memory key, SwapParams memory p, uint256 pay) external returns (BalanceDelta d) {
        Currency input = p.zeroForOne ? key.currency0 : key.currency1;
        IERC20(Currency.unwrap(input)).transferFrom(msg.sender, address(this), pay);
        d = abi.decode(manager.unlock(abi.encode(msg.sender, key, p, pay)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address user, PoolKey memory key, SwapParams memory p, uint256 pay) =
            abi.decode(data, (address, PoolKey, SwapParams, uint256));
        Currency input = p.zeroForOne ? key.currency0 : key.currency1;
        Currency output = p.zeroForOne ? key.currency1 : key.currency0;
        manager.sync(input);
        IERC20(Currency.unwrap(input)).transfer(address(manager), pay);
        BalanceDelta d = manager.swap(key, p, "");
        manager.settle();
        int128 inD = p.zeroForOne ? d.amount0() : d.amount1();
        int128 outD = p.zeroForOne ? d.amount1() : d.amount0();
        uint256 spent = uint256(-int256(inD));
        if (pay > spent) manager.take(input, user, pay - spent);
        manager.take(output, user, uint128(outD));
        return abi.encode(d);
    }
}

contract PrepaidRouterProofTest is Test {
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    PoolManager manager;
    SIMDTEST token;
    SIMDTESTHook hook;
    PoolKey key;
    PrepayRouter router;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, address(new PlainERC20()).code);
        token = new SIMDTEST();
        hook = _deployHook();
        key = hook.rewardRouter().poolKey();
        manager.initialize(key, Q96);
        PoolModifyLiquidityTest lp = new PoolModifyLiquidityTest(manager);
        PlainERC20(IMD).mint(address(this), 100_000_000 ether);
        IERC20(IMD).approve(address(lp), type(uint256).max);
        token.approve(address(lp), type(uint256).max);
        lp.modifyLiquidity(key, ModifyLiquidityParams(-600, 600, 10_000_000 ether, 0), "");
        router = new PrepayRouter(manager);
        PlainERC20(IMD).mint(alice, 1_000 ether);
        token.transfer(alice, 1_000 ether);
        vm.startPrank(alice);
        IERC20(IMD).approve(address(router), type(uint256).max);
        token.approve(address(router), type(uint256).max);
        vm.stopPrank();
    }

    function _deployHook() internal returns (SIMDTESTHook) {
        bytes memory code = abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, token));
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address at =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(at, HookFlags.FLAGS)) continue;
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(code, 32), mload(code), salt) }
            require(deployed == at, "mined deployment failed");
            return SIMDTESTHook(deployed);
        }
        revert("salt not found");
    }

    function _limit(bool zeroForOne) internal pure returns (uint160) {
        return zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
    }

    /// A sell (token in) through the prepaying router works: the hook's take moves IMD, not the synced token.
    function test_prepaidSellSucceeds() public {
        bool zeroForOne = address(token) < IMD;
        vm.prank(alice);
        router.swap(key, SwapParams(zeroForOne, -100 ether, _limit(zeroForOne)), 100 ether);
        assertEq(IERC20(IMD).balanceOf(address(hook)), IERC20(IMD).balanceOf(address(hook)));
    }

    /// The same router buying (IMD in) reverts: afterSwap takes the 2 IMD fee out of the manager
    /// between the router's sync and settle, so settle credits only 98 of the 100 IMD paid.
    function test_prepaidExactInputBuySucceeds() public {
        bool zeroForOne = IMD < address(token);
        uint256 before = token.balanceOf(alice);
        vm.prank(alice);
        router.swap(key, SwapParams(zeroForOne, -100 ether, _limit(zeroForOne)), 100 ether);
        assertGt(token.balanceOf(alice), before, "buyer received no SIMDTEST");
        assertEq(IERC20(IMD).balanceOf(alice), 900 ether);
        assertEq(IERC20(IMD).balanceOf(address(hook)) + manager.balanceOf(address(hook), uint160(IMD)), 2 ether);
    }
}

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

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

contract PlainERC20 is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

/// @dev A router that pays before swapping: sync -> transfer -> swap -> settle. v4 only requires that
/// the balance change between sync and settle equals the payment; the hook's take breaks that.
contract PrepayRouter is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }

    function swap(PoolKey memory key, SwapParams memory p, uint256 pay) external returns (BalanceDelta d) {
        Currency input = p.zeroForOne ? key.currency0 : key.currency1;
        IERC20(Currency.unwrap(input)).transferFrom(msg.sender, address(this), pay);
        d = abi.decode(manager.unlock(abi.encode(msg.sender, key, p, pay)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address user, PoolKey memory key, SwapParams memory p, uint256 pay) =
            abi.decode(data, (address, PoolKey, SwapParams, uint256));
        Currency input = p.zeroForOne ? key.currency0 : key.currency1;
        Currency output = p.zeroForOne ? key.currency1 : key.currency0;
        manager.sync(input);
        IERC20(Currency.unwrap(input)).transfer(address(manager), pay);
        BalanceDelta d = manager.swap(key, p, "");
        manager.settle();
        int128 inD = p.zeroForOne ? d.amount0() : d.amount1();
        int128 outD = p.zeroForOne ? d.amount1() : d.amount0();
        uint256 spent = uint256(-int256(inD));
        if (pay > spent) manager.take(input, user, pay - spent);
        manager.take(output, user, uint128(outD));
        return abi.encode(d);
    }
}

contract PrepaidRouterProofTest is Test {
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    PoolManager manager;
    SIMDTEST token;
    SIMDTESTHook hook;
    PoolKey key;
    PrepayRouter router;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, address(new PlainERC20()).code);
        token = new SIMDTEST();
        hook = _deployHook();
        key = hook.rewardRouter().poolKey();
        manager.initialize(key, Q96);
        PoolModifyLiquidityTest lp = new PoolModifyLiquidityTest(manager);
        PlainERC20(IMD).mint(address(this), 100_000_000 ether);
        IERC20(IMD).approve(address(lp), type(uint256).max);
        token.approve(address(lp), type(uint256).max);
        lp.modifyLiquidity(key, ModifyLiquidityParams(-600, 600, 10_000_000 ether, 0), "");
        router = new PrepayRouter(manager);
        PlainERC20(IMD).mint(alice, 1_000 ether);
        token.transfer(alice, 1_000 ether);
        vm.startPrank(alice);
        IERC20(IMD).approve(address(router), type(uint256).max);
        token.approve(address(router), type(uint256).max);
        vm.stopPrank();
    }

    function _deployHook() internal returns (SIMDTESTHook) {
        bytes memory code = abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, token));
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address at =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(at, HookFlags.FLAGS)) continue;
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(code, 32), mload(code), salt) }
            require(deployed == at, "mined deployment failed");
            return SIMDTESTHook(deployed);
        }
        revert("salt not found");
    }

    function _limit(bool zeroForOne) internal pure returns (uint160) {
        return zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
    }

    /// A sell (token in) through the prepaying router works: the hook's take moves IMD, not the synced token.
    function test_prepaidSellSucceeds() public {
        bool zeroForOne = address(token) < IMD;
        vm.prank(alice);
        router.swap(key, SwapParams(zeroForOne, -100 ether, _limit(zeroForOne)), 100 ether);
        assertEq(IERC20(IMD).balanceOf(address(hook)), IERC20(IMD).balanceOf(address(hook)));
    }

    /// The same router buying (IMD in) reverts: afterSwap takes the 2 IMD fee out of the manager
    /// between the router's sync and settle, so settle credits only 98 of the 100 IMD paid.
    function test_prepaidExactInputBuySucceeds() public {
        bool zeroForOne = IMD < address(token);
        uint256 before = token.balanceOf(alice);
        vm.prank(alice);
        router.swap(key, SwapParams(zeroForOne, -100 ether, _limit(zeroForOne)), 100 ether);
        assertGt(token.balanceOf(alice), before, "buyer received no SIMDTEST");
        assertEq(IERC20(IMD).balanceOf(alice), 900 ether);
        assertEq(IERC20(IMD).balanceOf(address(hook)) + manager.balanceOf(address(hook), uint160(IMD)), 2 ether);
    }
}

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

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

contract PlainIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

/// @dev Minimal direct PoolManager integrator: swap, then settle input and take output.
contract RawSwapper is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }

    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta d) {
        d = abi.decode(manager.unlock(abi.encode(key, p)), (BalanceDelta));
    }

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

    function _settleOrTake(Currency c, int128 amount) internal {
        if (amount < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(-int256(amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(c, address(this), uint128(amount));
        }
    }
}

contract OverflowProofTest is Test {
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    PoolManager manager;
    SIMDTEST token;
    SIMDTESTHook hook;
    PoolKey key;
    PoolKey plain;
    RawSwapper swapper;
    PoolModifyLiquidityTest lp;

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, address(new PlainIMD()).code);
        token = new SIMDTEST();
        hook = _deployHook();
        key = hook.rewardRouter().poolKey();
        plain = PoolKey(key.currency0, key.currency1, 12500, 60, IHooks(address(0)));
        manager.initialize(key, Q96);
        manager.initialize(plain, Q96);
        lp = new PoolModifyLiquidityTest(manager);
        PlainIMD(IMD).mint(address(this), 100_000_000 ether);
        IERC20(IMD).approve(address(lp), type(uint256).max);
        token.approve(address(lp), type(uint256).max);
        lp.modifyLiquidity(key, ModifyLiquidityParams(-600, 600, 10_000_000 ether, 0), "");
        lp.modifyLiquidity(plain, ModifyLiquidityParams(-600, 600, 10_000_000 ether, 0), "");
        swapper = new RawSwapper(manager);
        token.transfer(address(swapper), 10_000_000 ether);
    }

    function _deployHook() internal returns (SIMDTESTHook) {
        bytes memory code = abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, token));
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address at =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(at, HookFlags.FLAGS)) continue;
            address deployed;
            assembly ("memory-safe") { deployed := create2(0, add(code, 32), mload(code), salt) }
            require(deployed == at, "mined deployment failed");
            return SIMDTESTHook(deployed);
        }
        revert("salt not found");
    }

    /// An exact-output sell asking for "as much IMD as the price limit allows" (type(int256).max)
    /// fills partially on a plain pool, but the hooked pool reverts: beforeSwap adds N/49 to N with
    /// checked arithmetic and panics (0x11) before the fill-based cap is applied.
    function test_maxExactOutputSellDoesNotRevert() public {
        bool zeroForOne = address(token) < IMD; // sell SIMDTEST for IMD
        uint160 limit = zeroForOne ? uint160(Q96 * 99 / 100) : uint160(Q96 * 101 / 100);

        // Control: the same request on the hookless twin pool partially fills to the limit.
        BalanceDelta ref = swapper.swap(plain, SwapParams(zeroForOne, type(int256).max, limit));
        int128 refIMD = (IMD < address(token)) ? ref.amount0() : ref.amount1();
        assertGt(refIMD, 0, "plain pool fills to the limit");

        // Control: a merely huge request on the hooked pool works (fee is capped to the fill).
        BalanceDelta big = swapper.swap(key, SwapParams(zeroForOne, int256(1 << 250), limit));
        int128 bigIMD = (IMD < address(token)) ? big.amount0() : big.amount1();
        assertGt(bigIMD, 0, "hooked pool fills 2^250 request");

        // Defect: type(int256).max reverts on the hooked pool.
        BalanceDelta d = swapper.swap(key, SwapParams(zeroForOne, type(int256).max, limit));
        int128 gotIMD = (IMD < address(token)) ? d.amount0() : d.amount1();
        assertGt(gotIMD, 0, "hooked pool must also fill the max request instead of reverting");
    }
}