// 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";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("Identity", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice The batch budget is a fixed quarter of a balance that only a successful batch can lower.
/// Once that quarter exceeds the IMD the pool can absorb inside the 300-tick terminal limit, every
/// batch reverts with SlippageExceeded, and trading only enlarges the budget. Nobody is paid to call
/// executeBatch, so fees accumulating for a day before the first call is an ordinary launch.
/// Fails on the current code (the batch never executes); passes once the batch sizes its spend
/// to what the pool can fill inside the limit (or otherwise lets a smaller spend proceed).
contract ProofBatchDeadlockTest is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;

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

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

    function setUp() public {
        vm.warp(10_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new ProofIMD()).code);
        ProofIMD(IMD).mint(address(this), 2_000_000_000 ether);
        address tokenAddress = address(uint160(IMD) + 1);
        deployCodeTo("SIMDTEST.sol:SIMDTEST", tokenAddress);
        token = SIMDTEST(tokenAddress);

        bytes32 initHash =
            keccak256(abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token))));
        bytes32 salt;
        for (uint256 i;; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if (uint160(predicted) & ((1 << 14) - 1) == 0x10cc) {
                salt = bytes32(i);
                break;
            }
        }
        hook = new SIMDTESTHook{salt: salt}(manager, address(token));
        key = hook.poolKey();
        manager.initialize(key, Q96);
        // 10M IMD / 10M SIMDTEST of full-range depth, price 1:1.
        manager.unlock(abi.encode(uint8(0), abi.encode(ModifyLiquidityParams(-887220, 887220, 10_000_000 ether, 0))));
    }

    function test_batchStillExecutesAfterADayOfVolumeWithoutAKeeper() public {
        // Twelve rounds: buy 5M IMD of SIMDTEST, sell it all back. About 120M IMD of volume on a
        // 10M IMD-deep pool, price back near the start. No one calls executeBatch meanwhile.
        for (uint256 i; i < 12; i++) {
            vm.warp(block.timestamp + 600);
            BalanceDelta d = _swap(true, 5_000_000 ether);
            vm.warp(block.timestamp + 600);
            _swap(false, uint256(int256(d.amount1())));
        }
        // Two quiet hours: the one-hour mean tick equals the spot tick exactly.
        vm.warp(block.timestamp + 2 hours);
        (, int24 spot,,) = manager.getSlot0(hook.poolId());
        assertEq(hook.consult(), spot, "reference must equal spot for this proof");
        assertGt(hook.accruedFees(), hook.MIN_ACCRUED_FEES());

        // A calm pool, reference == spot, more than the minimum accrued, cooldown long over:
        // the brief's buyback must be able to spend "up to 25%" here.
        (uint256 spent, uint256 burned) = hook.executeBatch();
        assertGt(burned, 0);
        assertLe(spent, hook.totalFeesAccrued() / 4);
    }

    function _swap(bool buy, uint256 exactIn) internal returns (BalanceDelta) {
        bool zeroForOne = buy == hook.imdIsCurrency0();
        SwapParams memory p =
            SwapParams(zeroForOne, -int256(exactIn), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1);
        return abi.decode(manager.unlock(abi.encode(uint8(1), abi.encode(p))), (BalanceDelta));
    }

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

    function _settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            manager.sync(currency);
            ERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, address(this), uint128(delta));
        }
    }
}

// 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 {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("Identity", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice A price-limited swap that specifies IMD is charged the hook fee on the whole request,
/// not on the IMD that actually moved. The swapper pays far more than 1% of the trade.
contract PartialFillFeeProof is Test, IUnlockCallback {
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

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

    function setUp() public {
        vm.warp(10_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new ProofIMD()).code);
        ProofIMD(IMD).mint(address(this), 1_000_000_000 ether);
        // Either currency ordering reproduces; the test reads the ordering from the hook.
        token = new SIMDTEST();

        bytes32 initHash =
            keccak256(abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token))));
        bytes32 salt;
        for (uint256 i;; i++) {
            salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, initHash)))));
            if (uint160(predicted) & ((1 << 14) - 1) == 0x10cc) break;
        }
        hook = new SIMDTESTHook{salt: salt}(manager, address(token));
        key = hook.poolKey();
        manager.initialize(key, Q96);
        manager.unlock(abi.encode(uint8(0), abi.encode(ModifyLiquidityParams(-887220, 887220, 10_000_000 ether, bytes32(0)))));
    }

    /// @dev Seller asks for 100,000 IMD out, protected by a price limit one tick away. The pool
    /// fills only a few hundred IMD, but the hook keeps 100_000e18 / 99 of IMD. The seller leaves
    /// with tokens gone AND an IMD debt. Expected: the fee is at most 1% of the IMD the pool moved.
    function test_exactOutputSellWithPriceLimitIsChargedOnTheRequest() public {
        bool imdFirst = hook.imdIsCurrency0();
        uint160 limit = TickMath.getSqrtPriceAtTick(imdFirst ? int24(1) : int24(-1));
        uint256 imdBefore = _imdHeld();
        BalanceDelta delta = _swapLimit(!imdFirst, int256(100_000 ether), limit);
        int256 imd = imdFirst ? int256(delta.amount0()) : int256(delta.amount1());
        // Gross IMD the pool paid out = seller's net delta + the hook's fee (the net can be negative).
        int256 poolMoved = imd + int256(hook.accruedFees());
        emit log_named_uint("fee charged (IMD wei)", hook.accruedFees());
        emit log_named_int("gross IMD the pool paid", poolMoved);
        emit log_named_int("seller's net IMD delta", imd);
        emit log_named_int("tokens the seller gave", imdFirst ? int256(delta.amount1()) : int256(delta.amount0()));
        assertGe(_imdHeld(), imdBefore, "a seller of tokens paid IMD");
        assertLe(int256(hook.accruedFees()), poolMoved / 100 + 1, "hook fee exceeds 1% of the IMD leg");
    }

    /// @dev ERC-20 IMD plus any PoolManager IMD claim credited to this swapper (a refund path a fix may use).
    function _imdHeld() internal view returns (uint256) {
        return IERC20(IMD).balanceOf(address(this)) + manager.balanceOf(address(this), uint256(uint160(IMD)));
    }

    /// @dev Buyer offers up to 100,000 IMD with a limit one tick away; the pool consumes a few
    /// hundred IMD yet the hook keeps 1,000 IMD. Expected: at most 1% of the IMD consumed.
    function test_exactInputBuyWithPriceLimitIsChargedOnTheRequest() public {
        bool imdFirst = hook.imdIsCurrency0();
        uint160 limit = TickMath.getSqrtPriceAtTick(imdFirst ? int24(-1) : int24(1));
        BalanceDelta delta = _swapLimit(imdFirst, -int256(100_000 ether), limit);
        int256 imd = imdFirst ? int256(delta.amount0()) : int256(delta.amount1());
        // Swapper's gross IMD outlay minus what the hook kept is what the pool consumed.
        uint256 kept = hook.accruedFees() - manager.balanceOf(address(this), uint256(uint160(IMD)));
        uint256 consumed = uint256(-imd) - kept;
        emit log_named_uint("fee kept by hook (IMD wei)", kept);
        emit log_named_uint("IMD the pool actually consumed", consumed);
        assertLe(kept, consumed / 100 + 1, "hook fee exceeds 1% of the IMD leg");
    }

    function _swapLimit(bool zeroForOne, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(1), abi.encode(SwapParams(zeroForOne, amount, limit)))), (BalanceDelta)
        );
    }

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

    function _settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, address(this), uint128(delta));
        }
    }
}

// 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 {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 {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 IMDStandIn is ERC20 {
    constructor() ERC20("Identity", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice The batch budget is a fixed 24.75% of accrued fees and the batch refuses any partial
/// fill. Once accrued fees outgrow the liquidity inside the 300-tick band around the TWAP, every
/// executeBatch reverts with SlippageExceeded, and every further trade only enlarges the budget,
/// so the stall is self-reinforcing: the fees can never be spent by the hook itself.
contract Proof_BatchStall is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;

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

    IPoolManager internal manager;
    SIMDTEST internal token;
    SIMDTESTHook internal hook;
    PoolKey internal key;

    function setUp() public {
        vm.warp(10_000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new IMDStandIn()).code);
        IMDStandIn(IMD).mint(address(this), 10_000_000_000 ether);
        token = new SIMDTEST();
        bytes memory creation = abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token)));
        bytes32 initHash = keccak256(creation);
        for (uint256 i; i < 500_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if (uint160(predicted) & ((1 << 14) - 1) == 0x10cc) {
                hook = new SIMDTESTHook{salt: bytes32(i)}(manager, address(token));
                break;
            }
        }
        require(address(hook) != address(0), "no salt");
        key = hook.poolKey();
        manager.initialize(key, Q96);
        // Same depth as the project's own harness: 10M liquidity units over the full range.
        _liquidity(10_000_000 ether, -887220, 887220);
    }

    /// @dev Ordinary trading (wash-neutral, so the TWAP sits on the spot) accrues fees until the
    /// batch budget exceeds the IMD the pool can absorb within 300 ticks (~151k IMD at this depth).
    /// Expected: executeBatch spends at most a quarter of the fees and burns something.
    /// Actual: SlippageExceeded on every attempt, forever, and every further trade makes it worse.
    function test_batchExecutesWhenBudgetExceedsBandLiquidity() public {
        for (uint256 i; i < 45; i++) {
            vm.warp(block.timestamp + 60);
            BalanceDelta d = _swap(true, true, 1_000_000 ether); // buy 1M IMD exact input
            uint256 tokensBought = uint256(int256(_tokenDelta(d)));
            vm.warp(block.timestamp + 60);
            _swap(false, true, tokensBought); // sell the same tokens back: price returns near 1
        }
        vm.warp(block.timestamp + 1 hours);
        uint256 accrued = hook.accruedFees();
        emit log_named_decimal_uint("accrued IMD fees", accrued, 18);
        emit log_named_decimal_uint("batch budget", accrued / 4, 18);
        emit log_named_decimal_uint("IMD absorbable within 300 ticks", _bandCapacity(), 18);
        assertGt(accrued, hook.MIN_ACCRUED_FEES());
        int24 ref = hook.consult();
        (, int24 spot,,) = manager.getSlot0(hook.poolId());
        emit log_named_int("reference tick", ref);
        emit log_named_int("spot tick", spot);
        // Spot is on the favourable side of (or at) the reference, so nothing but the budget blocks.
        assertTrue(hook.imdIsCurrency0() ? spot >= ref - 5 : spot <= ref + 5, "spot not near reference");

        (uint256 spent, uint256 burned) = hook.executeBatch();
        assertLe(spent, accrued / 4, "spent more than a quarter");
        assertGt(burned, 0, "nothing burned");
        assertEq(token.balanceOf(hook.BURN_ADDRESS()), burned);
    }

    /// @dev IMD the pool absorbs from the current price down to the 300-tick limit, for a swap that
    /// buys SIMDTEST with IMD, at the full-range depth seeded above (ignoring the LP fee).
    function _bandCapacity() internal view returns (uint256) {
        (uint160 sqrtP, int24 spot,,) = manager.getSlot0(hook.poolId());
        uint128 L = manager.getLiquidity(hook.poolId());
        if (hook.imdIsCurrency0()) {
            uint160 sqrtLimit = TickMath.getSqrtPriceAtTick(spot - 300);
            // amount0 = L * (1/sqrtLimit - 1/sqrtP)
            return uint256(L) * (1 << 96) / sqrtLimit - uint256(L) * (1 << 96) / sqrtP;
        } else {
            uint160 sqrtLimit = TickMath.getSqrtPriceAtTick(spot + 300);
            // amount1 = L * (sqrtLimit - sqrtP)
            return uint256(L) * (sqrtLimit - sqrtP) / (1 << 96);
        }
    }

    function _liquidity(int256 amount, int24 lower, int24 upper) internal {
        manager.unlock(abi.encode(uint8(0), abi.encode(ModifyLiquidityParams(lower, upper, amount, bytes32(0)))));
    }

    function _swap(bool buy, bool exactInput, uint256 amount) internal returns (BalanceDelta) {
        bool zeroForOne = buy == hook.imdIsCurrency0();
        SwapParams memory p = SwapParams(
            zeroForOne,
            exactInput ? -int256(amount) : int256(amount),
            zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
        );
        return abi.decode(manager.unlock(abi.encode(uint8(1), abi.encode(p))), (BalanceDelta));
    }

    function _tokenDelta(BalanceDelta delta) internal view returns (int256) {
        return hook.imdIsCurrency0() ? int256(delta.amount1()) : int256(delta.amount0());
    }

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

    function _settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, address(this), uint128(delta));
        }
    }
}