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

import {Test} from "forge-std/Test.sol";
import {Kiln} from "src/Kiln.sol";
import {Launcher} from "src/Launcher.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
import {SwapParams, ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";

contract ProofZTO {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        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) {
        require(balanceOf[msg.sender] >= amount, "bal");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allow");
        allowance[from][msg.sender] -= amount;
        require(balanceOf[from] >= amount, "bal");
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ProofPEPEO {
    mapping(uint256 => address) public ownerOf;
    mapping(address => uint256) public balanceOf;

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

    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from && msg.sender == from, "owner");
        ownerOf[id] = to;
        balanceOf[from]--;
        balanceOf[to]++;
    }
}

/// Fails on the current code: once ETH buyers have consumed the whole ZTO-only range, the PoolManager holds
/// (almost) no ZTO, and Kiln.beforeSwap / afterSwap call poolManager.take(ZTO, kiln, cut) before the trader's
/// ZTO input is settled. The ERC-20 transfer inside take() reverts, so every ZTO-input swap with a nonzero cut
/// (tiers 0, 1 and 4) reverts even though the pool has ETH liquidity to sell into. Tier 21 (cut = 0) succeeds.
contract ZtoSellsRevertWhenPoolZtoExhaustedTest is Test {
    using StateLibrary for IPoolManager;

    ProofZTO zto;
    ProofPEPEO pepeo;
    IPoolManager manager;
    Kiln kiln;
    PoolKey key;
    PoolSwapTest router;
    PoolModifyLiquidityTest liquidityRouter;
    address buyer = makeAddr("buyer");
    address seller0 = makeAddr("seller0");
    address seller21 = makeAddr("seller21");

    receive() external payable {}

    function setUp() public {
        zto = new ProofZTO();
        pepeo = new ProofPEPEO();
        manager = new PoolManager(address(this));
        Launcher launcher = new Launcher(address(zto), address(pepeo), address(manager));
        bytes32 hash = launcher.initCodeHash();
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address p = address(uint160(uint256(keccak256(bytes.concat(hex"ff", bytes20(address(launcher)), salt, hash)))));
            if (uint160(p) & Hooks.ALL_HOOK_MASK == launcher.HOOK_FLAGS()) break;
        }
        kiln = launcher.open(salt, 1 << 96);
        key = kiln.poolKey();
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);

        // ZTO-only range below the opening raw tick, as the README prescribes.
        zto.mint(address(this), 1_000 ether);
        zto.approve(address(liquidityRouter), 1_000 ether);
        liquidityRouter.modifyLiquidity(key, ModifyLiquidityParams(-600, -60, 10_000 ether, bytes32(0)), "");

        for (uint256 i; i < 21; i++) pepeo.mint(seller21, i);
        for (uint256 i; i < 21; i++) pepeo.mint(buyer, 100 + i);
        vm.deal(buyer, 10_000 ether);
        zto.mint(seller0, 100 ether);
        zto.mint(seller21, 100 ether);
        vm.prank(seller0);
        zto.approve(address(router), type(uint256).max);
        vm.prank(seller21);
        zto.approve(address(router), type(uint256).max);

        // Demand exceeds the range: a buyer spends ETH until the price has crossed the whole ZTO range.
        vm.prank(buyer, buyer);
        router.swap{value: 5_000 ether}(
            key, SwapParams(true, -5_000 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        (, int24 tick,,) = manager.getSlot0(key.toId());
        assertLt(tick, -600, "price must have left the ZTO range");
        assertLt(zto.balanceOf(address(manager)), 1_000, "manager holds only ZTO dust");

        // Control: a tier-21 seller (cut = 0) can sell 10 ZTO into this exact pool state, so ETH liquidity
        // exists and the reverts below are caused only by the hook's take().
        uint256 snapshot = vm.snapshotState();
        vm.prank(seller21, seller21);
        BalanceDelta control = router.swap(
            key, SwapParams(false, -10 ether, TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertGt(control.amount0(), 0);
        assertEq(control.amount1(), -10 ether);
        vm.revertToState(snapshot);
    }

    function test_tier0CanSellZtoIntoPoolAfterRangeIsBoughtOut() public {
        uint256 amount = 10 ether;
        uint256 ethBefore = seller0.balance;
        // A tier-0 seller must be able to sell too (the existing suite covers the cut arithmetic).
        vm.prank(seller0, seller0);
        BalanceDelta d = router.swap(
            key, SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertEq(d.amount1(), -int256(amount));
        assertGt(d.amount0(), 0);
        assertEq(seller0.balance - ethBefore, uint256(int256(d.amount0())));
    }

    function test_tier0CanBuyExactEthWithZtoAfterRangeIsBoughtOut() public {
        uint256 ethBefore = seller0.balance;
        vm.prank(seller0, seller0);
        BalanceDelta d = router.swap(
            key, SwapParams(false, int256(1 ether), TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertEq(d.amount0(), 1 ether);
        assertLt(d.amount1(), 0);
        assertEq(seller0.balance - ethBefore, 1 ether);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Kiln} from "src/Kiln.sol";
import {Launcher} from "src/Launcher.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
import {SwapParams, ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";

/// Minimal standard ERC-20 (reverts on insufficient balance, like Sepolia WETH9).
contract ZtoMock {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        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) {
        require(balanceOf[msg.sender] >= amount, "balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allowance");
        require(balanceOf[from] >= amount, "balance");
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// Minimal ERC-721 surface used by Kiln (balanceOf drives the tier).
contract PepeoMock {
    mapping(uint256 => address) public ownerOf;
    mapping(address => uint256) public balanceOf;

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

    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from && msg.sender == from, "auth");
        ownerOf[id] = to;
        balanceOf[from]--;
        balanceOf[to]++;
    }
}

/// Finding: Kiln takes its ZTO cut out of the PoolManager (poolManager.take) inside the swap
/// callbacks, i.e. BEFORE the router settles the trader's ZTO input. When the manager holds less
/// ZTO than the cut (this pool's ZTO has been bought out and no other pool on the manager holds
/// ZTO, the normal state for a freshly listed token), every ZTO-input swap by a tier 0/1/4 wallet
/// reverts, while the identical swap by a tier-21 wallet (cut 0) succeeds.
contract ZtoInputStarvedTest is Test {
    using StateLibrary for IPoolManager;

    ZtoMock internal zto;
    PepeoMock internal pepeo;
    IPoolManager internal manager;
    Launcher internal launcher;
    Kiln internal kiln;
    PoolKey internal key;
    PoolSwapTest internal router;
    PoolModifyLiquidityTest internal liquidityRouter;
    address internal tier0 = makeAddr("tier0");
    address internal tier21 = makeAddr("tier21");

    function setUp() public {
        zto = new ZtoMock();
        pepeo = new PepeoMock();
        manager = new PoolManager(address(this));
        launcher = new Launcher(address(zto), address(pepeo), address(manager));
        bytes32 hash = launcher.initCodeHash();
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(bytes.concat(hex"ff", bytes20(address(launcher)), salt, hash)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK == launcher.HOOK_FLAGS()) break;
        }
        kiln = launcher.open(salt, 1 << 96);
        key = kiln.poolKey();
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);

        // Deployer adds a ZTO-only range below the opening tick (the README's convention).
        zto.mint(address(this), 1_000 ether);
        zto.approve(address(liquidityRouter), 1_000 ether);
        liquidityRouter.modifyLiquidity(key, ModifyLiquidityParams(-600, -60, 1e21, bytes32(0)), "");

        for (uint256 i; i < 21; i++) pepeo.mint(tier21, i);
        for (uint256 i; i < 2; i++) {
            address t = i == 0 ? tier0 : tier21;
            zto.mint(t, 1_000 ether);
            vm.deal(t, 1_000 ether);
            vm.prank(t);
            zto.approve(address(router), type(uint256).max);
        }

        // Traders buy the whole ZTO range with ETH: the manager now holds (almost) no ZTO.
        vm.prank(tier21, tier21);
        router.swap{value: 500 ether}(
            key, SwapParams(true, -500 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        (, int24 tick,,) = manager.getSlot0(key.toId());
        assertLt(tick, -600, "price left the ZTO range: the pool is ETH-only now");
        assertLt(zto.balanceOf(address(manager)), 0.013 ether, "manager ZTO is below a 1.3% cut of 1 ZTO");
    }

    /// Expected: a tier-0 wallet sells 1 ZTO (exact input) into the ETH-only pool and pays its 1.3% cut.
    /// Actual on current code: beforeSwap -> poolManager.take(ZTO, kiln, 0.013e18) transfers ZTO the
    /// manager does not hold, the ERC-20 reverts and the whole swap fails.
    function test_tier0CanSellZtoExactInputIntoEthOnlyPool() public {
        uint256 reserveBefore = kiln.reserve();
        uint256 ztoBefore = zto.balanceOf(tier0);
        vm.prank(tier0, tier0);
        router.swap(
            key, SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertEq(ztoBefore - zto.balanceOf(tier0), 1 ether, "trader paid the full exact input");
        assertEq(kiln.reserve() - reserveBefore, 0.013 ether, "1.3% cut credited to reserve");
    }

    /// Expected: the ZTO-input exact-output path (afterSwap take) also works. Actual: same revert.
    function test_tier0CanSellZtoExactOutputIntoEthOnlyPool() public {
        uint256 reserveBefore = kiln.reserve();
        vm.prank(tier0, tier0);
        router.swap(
            key, SwapParams(false, 0.1 ether, TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertGt(kiln.reserve(), reserveBefore, "cut credited to reserve");
    }

    /// Control: same swap, same state, tier-21 wallet (cut 0) succeeds, so only the cut's take blocks.
    function test_tier21SellsZtoIntoEthOnlyPool() public {
        vm.prank(tier21, tier21);
        router.swap(
            key, SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Kiln} from "src/Kiln.sol";
import {Launcher} from "src/Launcher.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {SwapParams, ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";

/// Minimal WETH9-like ERC-20: transfer reverts on insufficient balance, returns true otherwise.
contract ZTO {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        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) {
        require(balanceOf[msg.sender] >= amount, "balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allowance");
        require(balanceOf[from] >= amount, "balance");
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract PEPEO {
    mapping(uint256 => address) public ownerOf;
    mapping(address => uint256) public balanceOf;

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

    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from, "owner");
        ownerOf[id] = to;
        balanceOf[from]--;
        balanceOf[to]++;
    }
}

/// The hook takes its ZTO cut from the PoolManager before the trader settles. Once ETH buyers have
/// consumed the whole ZTO-only position, the manager holds (almost) no ZTO, so every ZTO-in swap by a
/// fee-paying wallet reverts inside Kiln._take even though the trader is about to deposit far more ZTO
/// than the cut. Both tests fail on the current code and pass once the cut no longer depends on the
/// manager's pre-settlement ZTO balance.
contract TakeBeforeSettleTest is Test {
    ZTO zto;
    PEPEO pepeo;
    IPoolManager manager;
    Launcher launcher;
    Kiln kiln;
    PoolKey key;
    PoolSwapTest router;
    PoolModifyLiquidityTest liquidityRouter;
    address tier0 = makeAddr("tier0");
    address tier21 = makeAddr("tier21");

    receive() external payable {}

    function setUp() public {
        zto = new ZTO();
        pepeo = new PEPEO();
        manager = new PoolManager(address(this));
        launcher = new Launcher(address(zto), address(pepeo), address(manager));
        bytes32 hash = launcher.initCodeHash();
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(bytes.concat(hex"ff", bytes20(address(launcher)), salt, hash)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK == launcher.HOOK_FLAGS()) break;
        }
        kiln = launcher.open(salt, 1 << 96);
        key = kiln.poolKey();
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        zto.mint(address(this), 100_000 ether);
        zto.approve(address(liquidityRouter), 100_000 ether);
        // ZTO-only range below the opening tick, exactly as the project tests do.
        liquidityRouter.modifyLiquidity(key, ModifyLiquidityParams(-600, -60, 1_000_000 ether, bytes32(0)), "");
        for (uint256 i; i < 21; i++) {
            pepeo.mint(tier21, i);
        }
        vm.deal(tier0, 1_000_000 ether);
        vm.deal(tier21, 1_000_000 ether);
        zto.mint(tier0, 1_000 ether);
        zto.mint(tier21, 1_000 ether);
        vm.prank(tier0);
        zto.approve(address(router), type(uint256).max);
        vm.prank(tier21);
        zto.approve(address(router), type(uint256).max);

        // ETH buyer consumes the whole ZTO-only position: the manager keeps 1 wei of ZTO.
        vm.prank(tier0, tier0);
        router.swap{value: 100_000 ether}(
            key,
            SwapParams(true, -100_000 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        uint256 managerZto = zto.balanceOf(address(manager));
        emit log_named_uint("manager ZTO after drain (wei)", managerZto);
        assertLt(managerZto, uint256(1 ether) * 13000 / 1_000_000, "precondition: manager holds less than one cut");
        // A tier-21 wallet (cut 0) can still sell ZTO for ETH in this state; the pool itself is fine.
        vm.prank(tier21, tier21);
        BalanceDelta d = router.swap(
            key, SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertGt(d.amount0(), 0);
        // Return the manager to the starved state: tier-21 buys the ZTO back out (ETH in).
        vm.prank(tier21, tier21);
        router.swap{value: 10 ether}(
            key, SwapParams(true, -10 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        );
        assertLt(zto.balanceOf(address(manager)), uint256(1 ether) * 13000 / 1_000_000);
    }

    function test_tier0ZtoExactInputSwapSucceedsWhenManagerHoldsNoZto() public {
        uint256 ztoBefore = zto.balanceOf(tier0);
        uint256 reserveBefore = kiln.reserve();
        vm.prank(tier0, tier0);
        (bool ok,) = address(router).call(
            abi.encodeCall(
                PoolSwapTest.swap,
                (
                    key,
                    SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1),
                    PoolSwapTest.TestSettings(false, false),
                    ""
                )
            )
        );
        assertTrue(ok, "tier-0 ZTO-in exact-input swap reverted in Kiln._take");
        assertEq(zto.balanceOf(tier0), ztoBefore - 1 ether);
        assertEq(kiln.reserve() - reserveBefore, uint256(1 ether) * 13000 / 1_000_000);
    }

    function test_tier0ZtoExactOutputSwapSucceedsWhenManagerHoldsNoZto() public {
        uint256 ethBefore = tier0.balance;
        uint256 reserveBefore = kiln.reserve();
        vm.prank(tier0, tier0);
        (bool ok,) = address(router).call(
            abi.encodeCall(
                PoolSwapTest.swap,
                (
                    key,
                    SwapParams(false, 0.5 ether, TickMath.MAX_SQRT_PRICE - 1),
                    PoolSwapTest.TestSettings(false, false),
                    ""
                )
            )
        );
        assertTrue(ok, "tier-0 ZTO-in exact-output swap reverted in Kiln._take");
        assertEq(tier0.balance, ethBefore + 0.5 ether);
        assertGt(kiln.reserve(), reserveBefore);
    }
}