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

import {Test} from "forge-std/Test.sol";
import {SIMDTEST} from "src/SIMDTEST.sol";
import {SIMDTESTHook} from "src/SIMDTESTHook.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 {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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

contract MiniERC20 {
    string public name = "IMD fixture";
    string public symbol = "IMD";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

interface IERC20Min {
    function transferFrom(address, address, uint256) external returns (bool);
    function approve(address, uint256) external returns (bool);
    function transfer(address, uint256) external returns (bool);
    function balanceOf(address) external view returns (uint256);
}

/// @dev Minimal router: swap or add liquidity, settling with the payer's ERC-20 approvals.
contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, msg.sender, key, abi.encode(p))), (BalanceDelta));
    }

    function liquidity(PoolKey memory key, int24 lo, int24 hi, int256 amount) external {
        manager.unlock(abi.encode(false, msg.sender, key, abi.encode(ModifyLiquidityParams(lo, hi, amount, 0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, address payer, PoolKey memory key, bytes memory payload) =
            abi.decode(data, (bool, address, PoolKey, bytes));
        BalanceDelta d;
        if (isSwap) d = manager.swap(key, abi.decode(payload, (SwapParams)), "");
        else (d,) = manager.modifyLiquidity(key, abi.decode(payload, (ModifyLiquidityParams)), "");
        _settle(key.currency0, d.amount0(), payer);
        _settle(key.currency1, d.amount1(), payer);
        return abi.encode(d);
    }

    function _settle(Currency c, int128 delta, address payer) private {
        if (delta < 0) {
            manager.sync(c);
            require(IERC20Min(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-int256(delta))));
            manager.settle();
        } else if (delta > 0) {
            manager.take(c, payer, uint128(delta));
        }
    }
}

/// @notice A zero-fill swap through an empty liquidity region moves spot to the price limit at no
///         cost. The hook records that untraded tick in its time-weighted reference, and the next
///         batch therefore spends nothing although the pool still offers tokens at the true price.
contract ZeroFillReferenceProof is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    IPoolManager manager;
    SIMDTEST token;
    SIMDTESTHook hook;
    Router router;
    PoolKey key;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new MiniERC20()).code);
        MiniERC20(IMD).mint(address(this), 10_000_000 ether);

        // Launch token below IMD so the token is currency0 (the IMD-is-currency1 ordering).
        bytes32 tokenHash = keccak256(type(SIMDTEST).creationCode);
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), bytes32(i), tokenHash))))
            );
            if (predicted < IMD) {
                token = new SIMDTEST{salt: bytes32(i)}();
                break;
            }
        }
        bytes32 hookHash =
            keccak256(abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token))));
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), bytes32(i), hookHash))))
            );
            if ((uint160(predicted) & 0x3fff) == 0x20c4) {
                hook = new SIMDTESTHook{salt: bytes32(i)}(manager, address(token));
                break;
            }
        }
        key = hook.poolKey();
        assertFalse(hook.pairedIsCurrency0());
        router = new Router(manager);
        token.approve(address(router), type(uint256).max);
        IERC20Min(IMD).approve(address(router), type(uint256).max);

        manager.initialize(key, Q96);
        // Token-only seed: a position entirely above spot holds only currency0 (the launch token).
        router.liquidity(key, 60, 600, 10_000_000 ether);
        assertEq(IERC20Min(IMD).balanceOf(address(manager)), 0);
        // Buyback funds already accrued to the hook.
        IERC20Min(IMD).transfer(address(hook), 1000 ether);
    }

    function test_zeroFillSwapDoesNotStallTheBuyback() public {
        vm.warp(block.timestamp + 1);
        uint256 tokBefore = token.balanceOf(address(this));
        uint256 imdBefore = IERC20Min(IMD).balanceOf(address(this));

        // Attacker: sell 1 wei of token toward MIN price. Nothing below spot is liquid: fill is zero.
        BalanceDelta d = router.swap(key, SwapParams(true, -1, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(d.amount0(), 0);
        assertEq(d.amount1(), 0);
        assertEq(token.balanceOf(address(this)), tokBefore, "attacker paid nothing");
        assertEq(IERC20Min(IMD).balanceOf(address(this)), imdBefore);
        (uint160 spot,,,) = manager.getSlot0(key.toId());
        assertEq(spot, TickMath.MIN_SQRT_PRICE + 1, "spot moved to the limit for free");

        vm.warp(block.timestamp + 3599);
        uint256 pendingBefore = hook.pending();
        (uint256 spent, uint256 burned) = hook.executeBatch();
        emit log_named_int("reference tick used", TickMath.getTickAtSqrtPrice(hook.referencePrice()));
        emit log_named_uint("spent", spent);
        emit log_named_uint("burned", burned);

        // Tokens are still on offer from tick 60 upward at the true price; a reference that only
        // reflects traded prices lets the batch buy them. On the current code spent == 0.
        assertGt(spent, 0, "batch stalled by an untraded reference tick");
        assertGt(burned, 0);
        assertEq(hook.pending(), pendingBefore - spent);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SIMDTEST} from "src/SIMDTEST.sol";
import {SIMDTESTHook} from "src/SIMDTESTHook.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 {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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

contract MiniERC20 {
    string public name = "IMD fixture";
    string public symbol = "IMD";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

interface IERC20Min {
    function transferFrom(address, address, uint256) external returns (bool);
    function approve(address, uint256) external returns (bool);
    function transfer(address, uint256) external returns (bool);
    function balanceOf(address) external view returns (uint256);
}

/// @dev Minimal router: swap or add liquidity, settling with the payer's ERC-20 approvals.
contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, msg.sender, key, abi.encode(p))), (BalanceDelta));
    }

    function liquidity(PoolKey memory key, int24 lo, int24 hi, int256 amount) external {
        manager.unlock(abi.encode(false, msg.sender, key, abi.encode(ModifyLiquidityParams(lo, hi, amount, 0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, address payer, PoolKey memory key, bytes memory payload) =
            abi.decode(data, (bool, address, PoolKey, bytes));
        BalanceDelta d;
        if (isSwap) d = manager.swap(key, abi.decode(payload, (SwapParams)), "");
        else (d,) = manager.modifyLiquidity(key, abi.decode(payload, (ModifyLiquidityParams)), "");
        _settle(key.currency0, d.amount0(), payer);
        _settle(key.currency1, d.amount1(), payer);
        return abi.encode(d);
    }

    function _settle(Currency c, int128 delta, address payer) private {
        if (delta < 0) {
            manager.sync(c);
            require(IERC20Min(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-int256(delta))));
            manager.settle();
        } else if (delta > 0) {
            manager.take(c, payer, uint128(delta));
        }
    }
}

/// @notice A zero-fill swap through an empty liquidity region moves spot to the price limit at no
///         cost. The hook records that untraded tick in its time-weighted reference, and the next
///         batch therefore spends nothing although the pool still offers tokens at the true price.
contract ZeroFillReferenceProof is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    IPoolManager manager;
    SIMDTEST token;
    SIMDTESTHook hook;
    Router router;
    PoolKey key;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new MiniERC20()).code);
        MiniERC20(IMD).mint(address(this), 10_000_000 ether);

        // Launch token below IMD so the token is currency0 (the IMD-is-currency1 ordering).
        bytes32 tokenHash = keccak256(type(SIMDTEST).creationCode);
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), bytes32(i), tokenHash))))
            );
            if (predicted < IMD) {
                token = new SIMDTEST{salt: bytes32(i)}();
                break;
            }
        }
        bytes32 hookHash =
            keccak256(abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token))));
        for (uint256 i;; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), bytes32(i), hookHash))))
            );
            if ((uint160(predicted) & 0x3fff) == 0x20c4) {
                hook = new SIMDTESTHook{salt: bytes32(i)}(manager, address(token));
                break;
            }
        }
        key = hook.poolKey();
        assertFalse(hook.pairedIsCurrency0());
        router = new Router(manager);
        token.approve(address(router), type(uint256).max);
        IERC20Min(IMD).approve(address(router), type(uint256).max);

        manager.initialize(key, Q96);
        // Token-only seed: a position entirely above spot holds only currency0 (the launch token).
        router.liquidity(key, 60, 600, 10_000_000 ether);
        assertEq(IERC20Min(IMD).balanceOf(address(manager)), 0);
        // Buyback funds already accrued to the hook.
        IERC20Min(IMD).transfer(address(hook), 1000 ether);
    }

    function test_zeroFillSwapDoesNotStallTheBuyback() public {
        vm.warp(block.timestamp + 1);
        uint256 tokBefore = token.balanceOf(address(this));
        uint256 imdBefore = IERC20Min(IMD).balanceOf(address(this));

        // Attacker: sell 1 wei of token toward MIN price. Nothing below spot is liquid: fill is zero.
        BalanceDelta d = router.swap(key, SwapParams(true, -1, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(d.amount0(), 0);
        assertEq(d.amount1(), 0);
        assertEq(token.balanceOf(address(this)), tokBefore, "attacker paid nothing");
        assertEq(IERC20Min(IMD).balanceOf(address(this)), imdBefore);
        (uint160 spot,,,) = manager.getSlot0(key.toId());
        assertEq(spot, TickMath.MIN_SQRT_PRICE + 1, "spot moved to the limit for free");

        vm.warp(block.timestamp + 3599);
        uint256 pendingBefore = hook.pending();
        (uint256 spent, uint256 burned) = hook.executeBatch();
        emit log_named_int("reference tick used", TickMath.getTickAtSqrtPrice(hook.referencePrice()));
        emit log_named_uint("spent", spent);
        emit log_named_uint("burned", burned);

        // Tokens are still on offer from tick 60 upward at the true price; a reference that only
        // reflects traded prices lets the batch buy them. On the current code spent == 0.
        assertGt(spent, 0, "batch stalled by an untraded reference tick");
        assertGt(burned, 0);
        assertEq(hook.pending(), pendingBefore - spent);
    }
}